# Yahoo! UI Library

### json 3.0.0b1

Yahoo! UI Library > json > JSON
Search:
Filters
Show Private Show Protected Show Deprecated

## `static` Class JSON

The JSON module adds support for serializing JavaScript objects into JSON strings and parsing JavaScript objects from strings in JSON format.

The JSON namespace is added to your YUI instance including static methods Y.JSON.parse(..) and Y.JSON.stringify(..).

The functionality and method signatures follow the ECMAScript 5 specification. In browsers with native JSON support, the native implementation is used.

The `json` module is a rollup of `json-parse` and `json-stringify`.

As their names suggest, `json-parse` adds support for parsing JSON data (Y.JSON.parse) and `json-stringify` for serializing JavaScript data into JSON strings (Y.JSON.stringify). You may choose to include either of the submodules individually if you don't need the complementary functionality, or include the rollup for both.

### Properties

#### _BRACKETS - `private {RegExp}`

Third step in the safety evaluation. Regex used to remove all open square brackets following a colon, comma, or at the beginning of the string.

#### _CHARS - `protected static {Object}`

Character substitution map for common escapes and special characters.

#### _ESCAPES - `private {RegExp}`

First step in the safety evaluation. Regex used to replace all escape sequences (i.e. "\\", etc) with '@' characters (a non-JSON character).

#### _INVALID - `private {RegExp}`

Final step in the safety evaluation. Regex used to test the string left after all previous replacements for invalid characters.

#### _SIMPLE - `private {RegExp}`

Test for JSON string of simple data string, number, boolean, or null. E.g. '"some string"', "true", "false", "null", or numbers "-123e+7" This was needed for some WIP native implementations (FF3.1b2) but may be unnecessary now.

#### _SPECIAL_CHARS - `protected {RegExp}`

Regex used to capture characters that need escaping before enclosing their containing string in quotes.

#### _UNICODE_EXCEPTIONS - `private {RegExp}`

Replace certain Unicode characters that JavaScript may handle incorrectly during eval--either by deleting them or treating them as line endings--with escape sequences. IMPORTANT NOTE: This regex will be used to modify the input if a match is found.

#### _VALUES - `private {RegExp}`

Second step in the safety evaluation. Regex used to replace all simple values with ']' characters.

#### Native - `private {Object}`

Alias to native browser implementation of the JSON object if available.

### Methods

#### _revive

`private MIXED _revive ( data , reviver )`
Traverses nested objects, applying a reviver function to each (key,value) from the scope if the key:value's containing object. The value returned from the function will replace the original value in the key:value pair. If the value returned is undefined, the key will be omitted from the returned object.

Parameters:
  `data <MIXED>` Any JavaScript data
  `reviver <Function>` filter or mutation function

Returns: `MIXED`
  The results of the filtered data

#### dateToString

`static String dateToString ( d )`
Serializes a Date instance as a UTC date string. Used internally by stringify. Override this method if you need Dates serialized in a different format.

Parameters:
  `d <Date>` The Date to serialize

Returns: `String`
  stringified Date in UTC format YYYY-MM-DDTHH:mm:SSZ

#### escapeException

`private String escapeException ( c )`
Replaces specific unicode characters with their appropriate \unnnn format. Some browsers ignore certain characters during eval.

Parameters:
  `c <String>` Unicode character

Returns: `String`
  the \unnnn escapement of the character

#### parse

`static MIXED parse ( s , reviver )`
Parse a JSON string, returning the native JavaScript representation.

Parameters:
  `s <string>` JSON string data
  `reviver <function>` (optional) function(k,v) passed each key value pair of object literals, allowing pruning or altering values

Returns: `MIXED`
  the native JavaScript representation of the JSON string

#### stringify

`static string stringify ( o , w , ind )`

Converts an arbitrary value to a JSON string representation.

Objects with cyclical references will trigger an exception.

If a whitelist is provided, only matching object keys will be included. Alternately, a replacer function may be passed as the second parameter. This function is executed on every value in the input, and its return value will be used in place of the original value. This is useful to serialize specialized objects or class instances.

If a positive integer or non-empty string is passed as the third parameter, the output will be formatted with carriage returns and indentation for readability. If a String is passed (such as "\t") it will be used once for each indentation level. If a number is passed, that number of spaces will be used.

Parameters:
  `o <MIXED>` any arbitrary value to convert to JSON string
  `w <Array|Function>` (optional) whitelist of acceptable object keys to include, or a replacer function to modify the raw value before serialization
  `ind <Number|String>` (optional) indentation character or depth of spaces to format the output.

Returns: `string`
  JSON string representation of the input

Copyright © 2009 Yahoo! Inc. All rights reserved.