| 提交 | 用户 | 时间 | ||
| 1ac2bc | 1 | /* |
| 懒 | 2 | http://www.JSON.org/json2.js |
| 3 | 2009-08-17 | |
| 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 value | |
| 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 | /*members "", "\b", "\t", "\n", "\f", "\r", "\"", JSON, "\\", apply, | |
| 150 | call, charCodeAt, getUTCDate, getUTCFullYear, getUTCHours, | |
| 151 | getUTCMinutes, getUTCMonth, getUTCSeconds, hasOwnProperty, join, | |
| 152 | lastIndex, length, parse, prototype, push, replace, slice, stringify, | |
| 153 | test, toJSON, toString, valueOf | |
| 154 | */ | |
| 155 | ||
| 156 | "use strict"; | |
| 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 | this.JSON = {}; | |
| 163 | } | |
| 164 | ||
| 165 | (function () { | |
| 166 | ||
| 167 | function f(n) { | |
| 168 | // Format integers to have at least two digits. | |
| 169 | return n < 10 ? '0' + n : n; | |
| 170 | } | |
| 171 | ||
| 172 | if (typeof Date.prototype.toJSON !== 'function') { | |
| 173 | ||
| 174 | Date.prototype.toJSON = function (key) { | |
| 175 | ||
| 176 | return isFinite(this.valueOf()) ? | |
| 177 | this.getUTCFullYear() + '-' + | |
| 178 | f(this.getUTCMonth() + 1) + '-' + | |
| 179 | f(this.getUTCDate()) + 'T' + | |
| 180 | f(this.getUTCHours()) + ':' + | |
| 181 | f(this.getUTCMinutes()) + ':' + | |
| 182 | f(this.getUTCSeconds()) + 'Z' : null; | |
| 183 | }; | |
| 184 | ||
| 185 | String.prototype.toJSON = | |
| 186 | Number.prototype.toJSON = | |
| 187 | Boolean.prototype.toJSON = function (key) { | |
| 188 | return this.valueOf(); | |
| 189 | }; | |
| 190 | } | |
| 191 | ||
| 192 | var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, | |
| 193 | escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, | |
| 194 | gap, | |
| 195 | indent, | |
| 196 | meta = { // table of character substitutions | |
| 197 | '\b': '\\b', | |
| 198 | '\t': '\\t', | |
| 199 | '\n': '\\n', | |
| 200 | '\f': '\\f', | |
| 201 | '\r': '\\r', | |
| 202 | '"' : '\\"', | |
| 203 | '\\': '\\\\' | |
| 204 | }, | |
| 205 | rep; | |
| 206 | ||
| 207 | ||
| 208 | function quote(string) { | |
| 209 | ||
| 210 | // If the string contains no control characters, no quote characters, and no | |
| 211 | // backslash characters, then we can safely slap some quotes around it. | |
| 212 | // Otherwise we must also replace the offending characters with safe escape | |
| 213 | // sequences. | |
| 214 | ||
| 215 | escapable.lastIndex = 0; | |
| 216 | return escapable.test(string) ? | |
| 217 | '"' + string.replace(escapable, function (a) { | |
| 218 | var c = meta[a]; | |
| 219 | return typeof c === 'string' ? c : | |
| 220 | '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4); | |
| 221 | }) + '"' : | |
| 222 | '"' + string + '"'; | |
| 223 | } | |
| 224 | ||
| 225 | ||
| 226 | function str(key, holder) { | |
| 227 | // Produce a string from holder[key]. | |
| 228 | ||
| 229 | var i, // The loop counter. | |
| 230 | k, // The member key. | |
| 231 | v, // The member value. | |
| 232 | length, | |
| 233 | mind = gap, | |
| 234 | partial, | |
| 235 | value = holder[key]; | |
| 236 | ||
| 237 | // If the value has a toJSON method, call it to obtain a replacement value. | |
| 238 | ||
| 239 | if (value && typeof value === 'object' && | |
| 240 | typeof value.toJSON === 'function') { | |
| 241 | value = value.toJSON(key); | |
| 242 | } | |
| 243 | ||
| 244 | // If we were called with a replacer function, then call the replacer to | |
| 245 | // obtain a replacement value. | |
| 246 | ||
| 247 | if (typeof rep === 'function') { | |
| 248 | value = rep.call(holder, key, value); | |
| 249 | } | |
| 250 | ||
| 251 | // What happens next depends on the value's type. | |
| 252 | ||
| 253 | switch (typeof value) { | |
| 254 | case 'string': | |
| 255 | return quote(value); | |
| 256 | ||
| 257 | case 'number': | |
| 258 | ||
| 259 | // JSON numbers must be finite. Encode non-finite numbers as null. | |
| 260 | ||
| 261 | return isFinite(value) ? String(value) : 'null'; | |
| 262 | ||
| 263 | case 'boolean': | |
| 264 | case 'null': | |
| 265 | ||
| 266 | // If the value is a boolean or null, convert it to a string. Note: | |
| 267 | // typeof null does not produce 'null'. The case is included here in | |
| 268 | // the remote chance that this gets fixed someday. | |
| 269 | ||
| 270 | return String(value); | |
| 271 | ||
| 272 | // If the type is 'object', we might be dealing with an object or an array or | |
| 273 | // null. | |
| 274 | ||
| 275 | case 'object': | |
| 276 | ||
| 277 | // Due to a specification blunder in ECMAScript, typeof null is 'object', | |
| 278 | // so watch out for that case. | |
| 279 | ||
| 280 | if (!value) { | |
| 281 | return 'null'; | |
| 282 | } | |
| 283 | ||
| 284 | // Make an array to hold the partial results of stringifying this object value. | |
| 285 | ||
| 286 | gap += indent; | |
| 287 | partial = []; | |
| 288 | ||
| 289 | // Is the value an array? | |
| 290 | ||
| 291 | if (Object.prototype.toString.apply(value) === '[object Array]') { | |
| 292 | ||
| 293 | // The value is an array. Stringify every element. Use null as a placeholder | |
| 294 | // for non-JSON values. | |
| 295 | ||
| 296 | length = value.length; | |
| 297 | for (i = 0; i < length; i += 1) { | |
| 298 | partial[i] = str(i, value) || 'null'; | |
| 299 | } | |
| 300 | ||
| 301 | // Join all of the elements together, separated with commas, and wrap them in | |
| 302 | // brackets. | |
| 303 | ||
| 304 | v = partial.length === 0 ? '[]' : | |
| 305 | gap ? '[\n' + gap + | |
| 306 | partial.join(',\n' + gap) + '\n' + | |
| 307 | mind + ']' : | |
| 308 | '[' + partial.join(',') + ']'; | |
| 309 | gap = mind; | |
| 310 | return v; | |
| 311 | } | |
| 312 | ||
| 313 | // If the replacer is an array, use it to select the members to be stringified. | |
| 314 | ||
| 315 | if (rep && typeof rep === 'object') { | |
| 316 | length = rep.length; | |
| 317 | for (i = 0; i < length; i += 1) { | |
| 318 | k = rep[i]; | |
| 319 | if (typeof k === 'string') { | |
| 320 | v = str(k, value); | |
| 321 | if (v) { | |
| 322 | partial.push(quote(k) + (gap ? ': ' : ':') + v); | |
| 323 | } | |
| 324 | } | |
| 325 | } | |
| 326 | } else { | |
| 327 | ||
| 328 | // Otherwise, iterate through all of the keys in the object. | |
| 329 | ||
| 330 | for (k in value) { | |
| 331 | if (Object.hasOwnProperty.call(value, k)) { | |
| 332 | v = str(k, value); | |
| 333 | if (v) { | |
| 334 | partial.push(quote(k) + (gap ? ': ' : ':') + v); | |
| 335 | } | |
| 336 | } | |
| 337 | } | |
| 338 | } | |
| 339 | ||
| 340 | // Join all of the member texts together, separated with commas, | |
| 341 | // and wrap them in braces. | |
| 342 | ||
| 343 | v = partial.length === 0 ? '{}' : | |
| 344 | gap ? '{\n' + gap + partial.join(',\n' + gap) + '\n' + | |
| 345 | mind + '}' : '{' + partial.join(',') + '}'; | |
| 346 | gap = mind; | |
| 347 | return v; | |
| 348 | } | |
| 349 | } | |
| 350 | ||
| 351 | // If the JSON object does not yet have a stringify method, give it one. | |
| 352 | ||
| 353 | if (typeof JSON.stringify !== 'function') { | |
| 354 | JSON.stringify = function (value, replacer, space) { | |
| 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 | }()); | |
