| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 http://www.JSON.org/json2.js | |
| 3 2008-11-19 | |
| 4 | |
| 5 Public Domain. | |
| 6 | |
| 7 NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK. | |
| 8 | |
| 9 See http://www.JSON.org/js.html | |
| 10 | |
| 11 This file creates a global JSON object containing two methods: stringify | |
| 12 and parse. | |
| 13 | |
| 14 JSON.stringify(value, replacer, space) | |
| 15 value any JavaScript value, usually an object or array. | |
| 16 | |
| 17 replacer an optional parameter that determines how object | |
| 18 values are stringified for objects. It can be a | |
| 19 function or an array of strings. | |
| 20 | |
| 21 space an optional parameter that specifies the indentation | |
| 22 of nested structures. If it is omitted, the text will | |
| 23 be packed without extra whitespace. If it is a number, | |
| 24 it will specify the number of spaces to indent at each | |
| 25 level. If it is a string (such as '\t' or ' '), | |
| 26 it contains the characters used to indent at each level. | |
| 27 | |
| 28 This method produces a JSON text from a JavaScript value. | |
| 29 | |
| 30 When an object value is found, if the object contains a toJSON | |
| 31 method, its toJSON method will be called and the result will be | |
| 32 stringified. A toJSON method does not serialize: it returns the | |
| 33 value represented by the name/value pair that should be serialized, | |
| 34 or undefined if nothing should be serialized. The toJSON method | |
| 35 will be passed the key associated with the value, and this will be | |
| 36 bound to the object holding the key. | |
| 37 | |
| 38 For example, this would serialize Dates as ISO strings. | |
| 39 | |
| 40 Date.prototype.toJSON = function (key) { | |
| 41 function f(n) { | |
| 42 // Format integers to have at least two digits. | |
| 43 return n < 10 ? '0' + n : n; | |
| 44 } | |
| 45 | |
| 46 return this.getUTCFullYear() + '-' + | |
| 47 f(this.getUTCMonth() + 1) + '-' + | |
| 48 f(this.getUTCDate()) + 'T' + | |
| 49 f(this.getUTCHours()) + ':' + | |
| 50 f(this.getUTCMinutes()) + ':' + | |
| 51 f(this.getUTCSeconds()) + 'Z'; | |
| 52 }; | |
| 53 | |
| 54 You can provide an optional replacer method. It will be passed the | |
| 55 key and value of each member, with this bound to the containing | |
| 56 object. The value that is returned from your method will be | |
| 57 serialized. If your method returns undefined, then the member will | |
| 58 be excluded from the serialization. | |
| 59 | |
| 60 If the replacer parameter is an array of strings, then it will be | |
| 61 used to select the members to be serialized. It filters the results | |
| 62 such that only members with keys listed in the replacer array are | |
| 63 stringified. | |
| 64 | |
| 65 Values that do not have JSON representations, such as undefined or | |
| 66 functions, will not be serialized. Such values in objects will be | |
| 67 dropped; in arrays they will be replaced with null. You can use | |
| 68 a replacer function to replace those with JSON values. | |
| 69 JSON.stringify(undefined) returns undefined. | |
| 70 | |
| 71 The optional space parameter produces a stringification of the | |
| 72 value that is filled with line breaks and indentation to make it | |
| 73 easier to read. | |
| 74 | |
| 75 If the space parameter is a non-empty string, then that string will | |
| 76 be used for indentation. If the space parameter is a number, then | |
| 77 the indentation will be that many spaces. | |
| 78 | |
| 79 Example: | |
| 80 | |
| 81 text = JSON.stringify(['e', {pluribus: 'unum'}]); | |
| 82 // text is '["e",{"pluribus":"unum"}]' | |
| 83 | |
| 84 | |
| 85 text = JSON.stringify(['e', {pluribus: 'unum'}], null, '\t'); | |
| 86 // text is '[\n\t"e",\n\t{\n\t\t"pluribus": "unum"\n\t}\n]' | |
| 87 | |
| 88 text = JSON.stringify([new Date()], function (key, value) { | |
| 89 return this[key] instanceof Date ? | |
| 90 'Date(' + this[key] + ')' : value; | |
| 91 }); | |
| 92 // text is '["Date(---current time---)"]' | |
| 93 | |
| 94 | |
| 95 JSON.parse(text, reviver) | |
| 96 This method parses a JSON text to produce an object or array. | |
| 97 It can throw a SyntaxError exception. | |
| 98 | |
| 99 The optional reviver parameter is a function that can filter and | |
| 100 transform the results. It receives each of the keys and values, | |
| 101 and its return value is used instead of the original value. | |
| 102 If it returns what it received, then the structure is not modified. | |
| 103 If it returns undefined then the member is deleted. | |
| 104 | |
| 105 Example: | |
| 106 | |
| 107 // Parse the text. Values that look like ISO date strings will | |
| 108 // be converted to Date objects. | |
| 109 | |
| 110 myData = JSON.parse(text, function (key, value) { | |
| 111 var a; | |
| 112 if (typeof value === 'string') { | |
| 113 a = | |
| 114 /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/.exec(value); | |
| 115 if (a) { | |
| 116 return new Date(Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4], | |
| 117 +a[5], +a[6])); | |
| 118 } | |
| 119 } | |
| 120 return value; | |
| 121 }); | |
| 122 | |
| 123 myData = JSON.parse('["Date(09/09/2001)"]', function (key, value) { | |
| 124 var d; | |
| 125 if (typeof value === 'string' && | |
| 126 value.slice(0, 5) === 'Date(' && | |
| 127 value.slice(-1) === ')') { | |
| 128 d = new Date(value.slice(5, -1)); | |
| 129 if (d) { | |
| 130 return d; | |
| 131 } | |
| 132 } | |
| 133 return value; | |
| 134 }); | |
| 135 | |
| 136 | |
| 137 This is a reference implementation. You are free to copy, modify, or | |
| 138 redistribute. | |
| 139 | |
| 140 This code should be minified before deployment. | |
| 141 See http://javascript.crockford.com/jsmin.html | |
| 142 | |
| 143 USE YOUR OWN COPY. IT IS EXTREMELY UNWISE TO LOAD CODE FROM SERVERS YOU DO | |
| 144 NOT CONTROL. | |
| 145 */ | |
| 146 | |
| 147 /*jslint evil: true */ | |
| 148 | |
| 149 /*global JSON */ | |
| 150 | |
| 151 /*members "", "\b", "\t", "\n", "\f", "\r", "\"", JSON, "\\", apply, | |
| 152 call, charCodeAt, getUTCDate, getUTCFullYear, getUTCHours, | |
| 153 getUTCMinutes, getUTCMonth, getUTCSeconds, hasOwnProperty, join, | |
| 154 lastIndex, length, parse, prototype, push, replace, slice, stringify, | |
| 155 test, toJSON, toString, valueOf | |
| 156 */ | |
| 157 | |
| 158 // Create a JSON object only if one does not already exist. We create the | |
| 159 // methods in a closure to avoid creating global variables. | |
| 160 | |
| 161 if (!this.JSON) { | |
| 162 JSON = {}; | |
| 163 } | |
| 164 (function () { | |
| 165 | |
| 166 function f(n) { | |
| 167 // Format integers to have at least two digits. | |
| 168 return n < 10 ? '0' + n : n; | |
| 169 } | |
| 170 | |
| 171 if (typeof Date.prototype.toJSON !== 'function') { | |
| 172 | |
| 173 Date.prototype.toJSON = function (key) { | |
| 174 | |
| 175 return this.getUTCFullYear() + '-' + | |
| 176 f(this.getUTCMonth() + 1) + '-' + | |
| 177 f(this.getUTCDate()) + 'T' + | |
| 178 f(this.getUTCHours()) + ':' + | |
| 179 f(this.getUTCMinutes()) + ':' + | |
| 180 f(this.getUTCSeconds()) + 'Z'; | |
| 181 }; | |
| 182 | |
| 183 String.prototype.toJSON = | |
| 184 Number.prototype.toJSON = | |
| 185 Boolean.prototype.toJSON = function (key) { | |
| 186 return this.valueOf(); | |
| 187 }; | |
| 188 } | |
| 189 | |
| 190 var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u
202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, | |
| 191 escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b
5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, | |
| 192 gap, | |
| 193 indent, | |
| 194 meta = { // table of character substitutions | |
| 195 '\b': '\\b', | |
| 196 '\t': '\\t', | |
| 197 '\n': '\\n', | |
| 198 '\f': '\\f', | |
| 199 '\r': '\\r', | |
| 200 '"' : '\\"', | |
| 201 '\\': '\\\\' | |
| 202 }, | |
| 203 rep; | |
| 204 | |
| 205 | |
| 206 function quote(string) { | |
| 207 | |
| 208 // If the string contains no control characters, no quote characters, and no | |
| 209 // backslash characters, then we can safely slap some quotes around it. | |
| 210 // Otherwise we must also replace the offending characters with safe escape | |
| 211 // sequences. | |
| 212 | |
| 213 escapable.lastIndex = 0; | |
| 214 return escapable.test(string) ? | |
| 215 '"' + string.replace(escapable, function (a) { | |
| 216 var c = meta[a]; | |
| 217 return typeof c === 'string' ? c : | |
| 218 '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4); | |
| 219 }) + '"' : | |
| 220 '"' + string + '"'; | |
| 221 } | |
| 222 | |
| 223 | |
| 224 function str(key, holder) { | |
| 225 | |
| 226 // Produce a string from holder[key]. | |
| 227 | |
| 228 var i, // The loop counter. | |
| 229 k, // The member key. | |
| 230 v, // The member value. | |
| 231 length, | |
| 232 mind = gap, | |
| 233 partial, | |
| 234 value = holder[key]; | |
| 235 | |
| 236 // If the value has a toJSON method, call it to obtain a replacement value. | |
| 237 | |
| 238 if (value && typeof value === 'object' && | |
| 239 typeof value.toJSON === 'function') { | |
| 240 value = value.toJSON(key); | |
| 241 } | |
| 242 | |
| 243 // If we were called with a replacer function, then call the replacer to | |
| 244 // obtain a replacement value. | |
| 245 | |
| 246 if (typeof rep === 'function') { | |
| 247 value = rep.call(holder, key, value); | |
| 248 } | |
| 249 | |
| 250 // What happens next depends on the value's type. | |
| 251 | |
| 252 switch (typeof value) { | |
| 253 case 'string': | |
| 254 return quote(value); | |
| 255 | |
| 256 case 'number': | |
| 257 | |
| 258 // JSON numbers must be finite. Encode non-finite numbers as null. | |
| 259 | |
| 260 return isFinite(value) ? String(value) : 'null'; | |
| 261 | |
| 262 case 'boolean': | |
| 263 case 'null': | |
| 264 | |
| 265 // If the value is a boolean or null, convert it to a string. Note: | |
| 266 // typeof null does not produce 'null'. The case is included here in | |
| 267 // the remote chance that this gets fixed someday. | |
| 268 | |
| 269 return String(value); | |
| 270 | |
| 271 // If the type is 'object', we might be dealing with an object or an array or | |
| 272 // null. | |
| 273 | |
| 274 case 'object': | |
| 275 | |
| 276 // Due to a specification blunder in ECMAScript, typeof null is 'object', | |
| 277 // so watch out for that case. | |
| 278 | |
| 279 if (!value) { | |
| 280 return 'null'; | |
| 281 } | |
| 282 | |
| 283 // Make an array to hold the partial results of stringifying this object value. | |
| 284 | |
| 285 gap += indent; | |
| 286 partial = []; | |
| 287 | |
| 288 // Is the value an array? | |
| 289 | |
| 290 if (Object.prototype.toString.apply(value) === '[object Array]') { | |
| 291 | |
| 292 // The value is an array. Stringify every element. Use null as a placeholder | |
| 293 // for non-JSON values. | |
| 294 | |
| 295 length = value.length; | |
| 296 for (i = 0; i < length; i += 1) { | |
| 297 partial[i] = str(i, value) || 'null'; | |
| 298 } | |
| 299 | |
| 300 // Join all of the elements together, separated with commas, and wrap them in | |
| 301 // brackets. | |
| 302 | |
| 303 v = partial.length === 0 ? '[]' : | |
| 304 gap ? '[\n' + gap + | |
| 305 partial.join(',\n' + gap) + '\n' + | |
| 306 mind + ']' : | |
| 307 '[' + partial.join(',') + ']'; | |
| 308 gap = mind; | |
| 309 return v; | |
| 310 } | |
| 311 | |
| 312 // If the replacer is an array, use it to select the members to be stringified. | |
| 313 | |
| 314 if (rep && typeof rep === 'object') { | |
| 315 length = rep.length; | |
| 316 for (i = 0; i < length; i += 1) { | |
| 317 k = rep[i]; | |
| 318 if (typeof k === 'string') { | |
| 319 v = str(k, value); | |
| 320 if (v) { | |
| 321 partial.push(quote(k) + (gap ? ': ' : ':') + v); | |
| 322 } | |
| 323 } | |
| 324 } | |
| 325 } else { | |
| 326 | |
| 327 // Otherwise, iterate through all of the keys in the object. | |
| 328 | |
| 329 for (k in value) { | |
| 330 if (Object.hasOwnProperty.call(value, k)) { | |
| 331 v = str(k, value); | |
| 332 if (v) { | |
| 333 partial.push(quote(k) + (gap ? ': ' : ':') + v); | |
| 334 } | |
| 335 } | |
| 336 } | |
| 337 } | |
| 338 | |
| 339 // Join all of the member texts together, separated with commas, | |
| 340 // and wrap them in braces. | |
| 341 | |
| 342 v = partial.length === 0 ? '{}' : | |
| 343 gap ? '{\n' + gap + partial.join(',\n' + gap) + '\n' + | |
| 344 mind + '}' : '{' + partial.join(',') + '}'; | |
| 345 gap = mind; | |
| 346 return v; | |
| 347 } | |
| 348 } | |
| 349 | |
| 350 // If the JSON object does not yet have a stringify method, give it one. | |
| 351 | |
| 352 if (typeof JSON.stringify !== 'function') { | |
| 353 JSON.stringify = function (value, replacer, space) { | |
| 354 | |
| 355 // The stringify method takes a value and an optional replacer, and an optional | |
| 356 // space parameter, and returns a JSON text. The replacer can be a function | |
| 357 // that can replace values, or an array of strings that will select the keys. | |
| 358 // A default replacer method can be provided. Use of the space parameter can | |
| 359 // produce text that is more easily readable. | |
| 360 | |
| 361 var i; | |
| 362 gap = ''; | |
| 363 indent = ''; | |
| 364 | |
| 365 // If the space parameter is a number, make an indent string containing that | |
| 366 // many spaces. | |
| 367 | |
| 368 if (typeof space === 'number') { | |
| 369 for (i = 0; i < space; i += 1) { | |
| 370 indent += ' '; | |
| 371 } | |
| 372 | |
| 373 // If the space parameter is a string, it will be used as the indent string. | |
| 374 | |
| 375 } else if (typeof space === 'string') { | |
| 376 indent = space; | |
| 377 } | |
| 378 | |
| 379 // If there is a replacer, it must be a function or an array. | |
| 380 // Otherwise, throw an error. | |
| 381 | |
| 382 rep = replacer; | |
| 383 if (replacer && typeof replacer !== 'function' && | |
| 384 (typeof replacer !== 'object' || | |
| 385 typeof replacer.length !== 'number')) { | |
| 386 throw new Error('JSON.stringify'); | |
| 387 } | |
| 388 | |
| 389 // Make a fake root object containing our value under the key of ''. | |
| 390 // Return the result of stringifying the value. | |
| 391 | |
| 392 return str('', {'': value}); | |
| 393 }; | |
| 394 } | |
| 395 | |
| 396 | |
| 397 // If the JSON object does not yet have a parse method, give it one. | |
| 398 | |
| 399 if (typeof JSON.parse !== 'function') { | |
| 400 JSON.parse = function (text, reviver) { | |
| 401 | |
| 402 // The parse method takes a text and an optional reviver function, and returns | |
| 403 // a JavaScript value if the text is a valid JSON text. | |
| 404 | |
| 405 var j; | |
| 406 | |
| 407 function walk(holder, key) { | |
| 408 | |
| 409 // The walk method is used to recursively walk the resulting structure so | |
| 410 // that modifications can be made. | |
| 411 | |
| 412 var k, v, value = holder[key]; | |
| 413 if (value && typeof value === 'object') { | |
| 414 for (k in value) { | |
| 415 if (Object.hasOwnProperty.call(value, k)) { | |
| 416 v = walk(value, k); | |
| 417 if (v !== undefined) { | |
| 418 value[k] = v; | |
| 419 } else { | |
| 420 delete value[k]; | |
| 421 } | |
| 422 } | |
| 423 } | |
| 424 } | |
| 425 return reviver.call(holder, key, value); | |
| 426 } | |
| 427 | |
| 428 | |
| 429 // Parsing happens in four stages. In the first stage, we replace certain | |
| 430 // Unicode characters with escape sequences. JavaScript handles many characters | |
| 431 // incorrectly, either silently deleting them, or treating them as line endings. | |
| 432 | |
| 433 cx.lastIndex = 0; | |
| 434 if (cx.test(text)) { | |
| 435 text = text.replace(cx, function (a) { | |
| 436 return '\\u' + | |
| 437 ('0000' + a.charCodeAt(0).toString(16)).slice(-4); | |
| 438 }); | |
| 439 } | |
| 440 | |
| 441 // In the second stage, we run the text against regular expressions that look | |
| 442 // for non-JSON patterns. We are especially concerned with '()' and 'new' | |
| 443 // because they can cause invocation, and '=' because it can cause mutation. | |
| 444 // But just to be safe, we want to reject all unexpected forms. | |
| 445 | |
| 446 // We split the second stage into 4 regexp operations in order to work around | |
| 447 // crippling inefficiencies in IE's and Safari's regexp engines. First we | |
| 448 // replace the JSON backslash pairs with '@' (a non-JSON character). Second, we | |
| 449 // replace all simple value tokens with ']' characters. Third, we delete all | |
| 450 // open brackets that follow a colon or comma or that begin the text. Finally, | |
| 451 // we look to see that the remaining characters are only whitespace or ']' or | |
| 452 // ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval. | |
| 453 | |
| 454 if (/^[\],:{}\s]*$/. | |
| 455 test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@'). | |
| 456 replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
. | |
| 457 replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) { | |
| 458 | |
| 459 // In the third stage we use the eval function to compile the text into a | |
| 460 // JavaScript structure. The '{' operator is subject to a syntactic ambiguity | |
| 461 // in JavaScript: it can begin a block or an object literal. We wrap the text | |
| 462 // in parens to eliminate the ambiguity. | |
| 463 | |
| 464 j = eval('(' + text + ')'); | |
| 465 | |
| 466 // In the optional fourth stage, we recursively walk the new structure, passing | |
| 467 // each name/value pair to a reviver function for possible transformation. | |
| 468 | |
| 469 return typeof reviver === 'function' ? | |
| 470 walk({'': j}, '') : j; | |
| 471 } | |
| 472 | |
| 473 // If the text is not JSON parseable, then a SyntaxError is thrown. | |
| 474 | |
| 475 throw new SyntaxError('JSON.parse'); | |
| 476 }; | |
| 477 } | |
| 478 })(); | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 56154:
Move json2.js to a common location. (Closed)
Base URL: svn://chrome-svn/chrome/trunk/src/