标记在IE8以下时使用JSON.stringify报JSON未定义错误的问题
Posted lele-house
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了标记在IE8以下时使用JSON.stringify报JSON未定义错误的问题相关的知识,希望对你有一定的参考价值。
调用的页面里引用json2.js即可解决问题(推荐方法)。
即:<script type="text/javascript" src="js/json2.js"></script>
json2.js如下:
// json2.js | |
// 2017-06-12 | |
// Public Domain. | |
// NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK. | |
// USE YOUR OWN COPY. IT IS EXTREMELY UNWISE TO LOAD CODE FROM SERVERS YOU DO | |
// NOT CONTROL. | |
// This file creates a global JSON object containing two methods: stringify | |
// and parse. This file provides the ES5 JSON capability to ES3 systems. | |
// If a project might run on IE8 or earlier, then this file should be included. | |
// This file does nothing on ES5 systems. | |
// JSON.stringify(value, replacer, space) | |
// value any JavaScript value, usually an object or array. | |
// replacer an optional parameter that determines how object | |
// values are stringified for objects. It can be a | |
// function or an array of strings. | |
// space an optional parameter that specifies the indentation | |
// of nested structures. If it is omitted, the text will | |
// be packed without extra whitespace. If it is a number, | |
// it will specify the number of spaces to indent at each | |
// level. If it is a string (such as " " or " "), | |
// it contains the characters used to indent at each level. | |
// This method produces a JSON text from a JavaScript value. | |
// When an object value is found, if the object contains a toJSON | |
// method, its toJSON method will be called and the result will be | |
// stringified. A toJSON method does not serialize: it returns the | |
// value represented by the name/value pair that should be serialized, | |
// or undefined if nothing should be serialized. The toJSON method | |
// will be passed the key associated with the value, and this will be | |
// bound to the value. | |
// For example, this would serialize Dates as ISO strings. | |
// Date.prototype.toJSON = function (key) { | |
// function f(n) { | |
// // Format integers to have at least two digits. | |
// return (n < 10) | |
// ? "0" + n | |
// : n; | |
// } | |
// return this.getUTCFullYear() + "-" + | |
// f(this.getUTCMonth() + 1) + "-" + | |
// f(this.getUTCDate()) + "T" + | |
// f(this.getUTCHours()) + ":" + | |
// f(this.getUTCMinutes()) + ":" + | |
// f(this.getUTCSeconds()) + "Z"; | |
// }; | |
// You can provide an optional replacer method. It will be passed the | |
// key and value of each member, with this bound to the containing | |
// object. The value that is returned from your method will be | |
// serialized. If your method returns undefined, then the member will | |
// be excluded from the serialization. | |
// If the replacer parameter is an array of strings, then it will be | |
// used to select the members to be serialized. It filters the results | |
// such that only members with keys listed in the replacer array are | |
// stringified. | |
// Values that do not have JSON representations, such as undefined or | |
// functions, will not be serialized. Such values in objects will be | |
// dropped; in arrays they will be replaced with null. You can use | |
// a replacer function to replace those with JSON values. | |
// JSON.stringify(undefined) returns undefined. | |
// The optional space parameter produces a stringification of the | |
// value that is filled with line breaks and indentation to make it | |
// easier to read. | |
// If the space parameter is a non-empty string, then that string will | |
// be used for indentation. If the space parameter is a number, then | |
// the indentation will be that many spaces. | |
// Example: | |
// text = JSON.stringify(["e", {pluribus: "unum"}]); | |
// // text is ‘["e",{"pluribus":"unum"}]‘ | |
// text = JSON.stringify(["e", {pluribus: "unum"}], null, " "); | |
// // text is ‘[ "e", { "pluribus": "unum" } ]‘ | |
// text = JSON.stringify([new Date()], function (key, value) { | |
// return this[key] instanceof Date | |
// ? "Date(" + this[key] + ")" | |
// : value; | |
// }); | |
// // text is ‘["Date(---current time---)"]‘ | |
// JSON.parse(text, reviver) | |
// This method parses a JSON text to produce an object or array. | |
// It can throw a SyntaxError exception. | |
// The optional reviver parameter is a function that can filter and | |
// transform the results. It receives each of the keys and values, | |
// and its return value is used instead of the original value. | |
// If it returns what it received, then the structure is not modified. | |
// If it returns undefined then the member is deleted. | |
// Example: | |
// // Parse the text. Values that look like ISO date strings will | |
// // be converted to Date objects. | |
// myData = JSON.parse(text, function (key, value) { | |
// var a; | |
// if (typeof value === "string") { | |
// a = | |
// /^(d{4})-(d{2})-(d{2})T(d{2}):(d{2}):(d{2}(?:.d*)?)Z$/.exec(value); | |
// if (a) { | |
// return new Date(Date.UTC( | |
// +a[1], +a[2] - 1, +a[3], +a[4], +a[5], +a[6] | |
// )); | |
// } | |
// return value; | |
// } | |
// }); | |
// myData = JSON.parse( | |
// "["Date(09/09/2001)"]", | |
// function (key, value) { | |
// var d; | |
// if ( | |
// typeof value === "string" | |
// && value.slice(0, 5) === "Date(" | |
// && value.slice(-1) === ")" | |
// ) { | |
// d = new Date(value.slice(5, -1)); | |
// if (d) { | |
// return d; | |
// } | |
// } | |
// return value; | |
// } | |
// ); | |
// This is a reference implementation. You are free to copy, modify, or | |
// redistribute. | |
/*jslint | |
eval, for, this | |
*/ | |
/*property | |
JSON, apply, call, charCodeAt, getUTCDate, getUTCFullYear, getUTCHours, | |
getUTCMinutes, getUTCMonth, getUTCSeconds, hasOwnProperty, join, | |
lastIndex, length, parse, prototype, push, replace, slice, stringify, | |
test, toJSON, toString, valueOf | |
*/ | |
// Create a JSON object only if one does not already exist. We create the | |
// methods in a closure to avoid creating global variables. | |
if (typeof JSON !== "object") { | |
JSON = {}; | |
} | |
(function () { | |
"use strict"; | |
var rx_one = /^[],:{}s]*$/; | |
var rx_two = /\(?:["\/bfnrt]|u[0-9a-fA-F]{4})/g; | |
var rx_three = /"[^"\ ]*"|true|false|null|-?d+(?:.d*)?(?:[eE][+-]?d+)?/g; | |
var rx_four = /(?:^|:|,)(?:s*[)+/g; | |
var rx_escapable = /[\"u0000-u001fu007f-u009fu00adu0600-u0604u070fu17b4u17b5u200c-u200fu2028-u202fu2060-u206fufeffufff0-uffff]/g; | |
var rx_dangerous = /[u0000u00adu0600-u0604u070fu17b4u17b5u200c-u200fu2028-u202fu2060-u206fufeffufff0-uffff]/g; | |
function f(n) { | |
// Format integers to have at least two digits. | |
return (n < 10) | |
? "0" + n | |
: n; | |
} | |
function this_value() { | |
return this.valueOf(); | |
} | |
if (typeof Date.prototype.toJSON !== "function") { | |
Date.prototype.toJSON = function () { | |
return isFinite(this.valueOf()) | |
? ( | |
this.getUTCFullYear() | |
+ "-" | |
+ f(this.getUTCMonth() + 1) | |
+ "-" | |
+ f(this.getUTCDate()) | |
+ "T" | |
+ f(this.getUTCHours()) | |
+ ":" | |
+ f(this.getUTCMinutes()) | |
+ ":" | |
+ f(this.getUTCSeconds()) | |
+ "Z" | |
) | |
: null; | |
}; | |
Boolean.prototype.toJSON = this_value; | |
Number.prototype.toJSON = this_value; | |
String.prototype.toJSON = this_value; | |
} | |
var gap; | |
var indent; | |
var meta; | |
var rep; | |
function quote(string) { | |
// If the string contains no control characters, no quote characters, and no | |
// backslash characters, then we can safely slap some quotes around it. | |
// Otherwise we must also replace the offending characters with safe escape | |
// sequences. | |
rx_escapable.lastIndex = 0; | |
return rx_escapable.test(string) | |
? """ + string.replace(rx_escapable, function (a) { | |
var c = meta[a]; | |
return typeof c === "string" | |
? c | |
: "\u" + ("0000" + a.charCodeAt(0).toString(16)).slice(-4); | |
}) + """ | |
: """ + string + """; | |
} | |
function str(key, holder) { | |
// Produce a string from holder[key]. | |
var i; // The loop counter. | |
var k; // The member key. | |
var v; // The member value. | |
var length; | |
var mind = gap; | |
var partial; | |
var value = holder[key]; | |
// If the value has a toJSON method, call it to obtain a replacement value. | |
if ( | |
value | |
&& typeof value === "object" | |
&& typeof value.toJSON === "function" | |
) { | |
value = value.toJSON(key); | |
} | |
// If we were called with a replacer function, then call the replacer to | |
// obtain a replacement value. | |
if (typeof rep === "function") { | |
value = rep.call(holder, key, value); | |
} | |
// What happens next depends on the value‘s type. | |
switch (typeof value) { | |
case "string": | |
return quote(value); | |
case "number": | |
// JSON numbers must be finite. Encode non-finite numbers as null. | |
return (isFinite(value)) | |
? String(value) | |
: "null"; | |
case "boolean": | |
case "null": | |
// If the value is a boolean or null, convert it to a string. Note: | |
// typeof null does not produce "null". The case is included here in | |
// the remote chance that this gets fixed someday. | |
return String(value); | |
// If the type is "object", we might be dealing with an object or an array or | |
// null. | |
case "object": | |
// Due to a specification blunder in ECMAScript, typeof null is "object", | |
// so watch out for that case. | |
if (!value) { | |
return "null"; | |
} | |
// Make an array to hold the partial results of stringifying this object value. | |
gap += indent; | |
partial = []; | |
// Is the value an array? | |
if (Object.prototype.toString.apply(value) === "[object Array]") { | |
// The value is an array. Stringify every element. Use null as a placeholder | |
// for non-JSON values. | |
length = value.length; | |
for (i = 0; i < length; i += 1) { | |
partial[i] = str(i, value) || "null"; | |
} | |
// Join all of the elements together, separated with commas, and wrap them in | |
// brackets. | |
v = partial.length === 0 | |
? "[]" | |
: gap | |
? ( | |
"[ " | |
+ gap | |
+ partial.join(", " + gap) | |
+ " " | |
+ mind | |
+ "]" | |
) | |
: "[" + partial.join(",") + "]"; | |
gap = mind; | |
return v; | |
} | |
// If the replacer is an array, use it to select the members to be stringified. | |
if (rep && typeof rep === "object") { | |
length = rep.length; | |
for (i = 0; i < length; i += 1) { | |
if (typeof rep[i] === "string") { | |
k = rep[i]; | |
v = str(k, value); | |
if (v) { | |
partial.push(quote(k) + ( | |
(gap) | |
? ": " | |
: ":" | |
) + v); | |
} | |
} | |
} | |
} else { | |
// Otherwise, iterate through all of the keys in the object. | |
for (k in value) { | |
if (Object.prototype.hasOwnProperty.call(value, k)) { | |
v = str(k, value); | |
if (v) { | |
partial.push(quote(k) + ( | |
(gap) | |
? ": " | |
: ":" | |
) + v); | |
} | |
} | |
} | |
} | |
// Join all of the member texts together, separated with commas, | |
// and wrap them in braces. | |
v = partial.length === 0 | |
? "{}" | |
: gap | |
? "{ " + gap + partial.join(", " + gap) + " " + mind + "}" | |
: "{" + partial.join(",") + "}"; | |
gap = mind; | |
return v; | |
} | |
} | |
// If the JSON object does not yet have a stringify method, give it one. | |
if (typeof JSON.stringify !== "function") { | |
meta = { // table of character substitutions | |
"": "\b", | |
" ": "\t", | |
" ": "\n", | |
"f": "\f", | |
" ": "\r", | |
""": "\"", | |
"\": "\\" | |
}; | |
JSON.stringify = function (value, replacer, space) { | |
// The stringify method takes a value and an optional replacer, and an optional | |
// space parameter, and returns a JSON text. The replacer can be a function | |
// that can replace values, or an array of strings that will select the keys. | |
// A default replacer method can be provided. Use of the space parameter can | |
// produce text that is more easily readable. | |
var i; | |
gap = ""; | |
indent = ""; | |
// If the space parameter is a number, make an indent string containing that | |
// many spaces. | |
if (typeof space === "number") { | |
for (i = 0; i < space; i += 1) { | |
indent += " "; | |
} | |
// If the space parameter is a string, it will be used as the indent string. | |
} else if (typeof space === "string") { | |
indent = space; | |
} | |
// If there is a replacer, it must be a function or an array. | |
// Otherwise, throw an error. | |
rep = replacer; | |
if (replacer && typeof replacer !== "function" && ( | |
typeof replacer !== "object" | |
|| typeof replacer.length !== "number" | |
)) { | |
throw new Error("JSON.stringify"); | |
} | |
// Make a fake root object containing our value under the key of "". | |
// Return the result of stringifying the value. | |
return str("", {"": value}); | |
}; | |
} | |
// If the JSON object does not yet have a parse method, give it one. | |
if (typeof JSON.parse !== "function") { | |
JSON.parse = function (text, reviver) { | |
// The parse method takes a text and an optional reviver function, and returns | |
// a JavaScript value if the text is a valid JSON text. | |
var j; | |
function walk(holder, key) { | |
// The walk method is used to recursively walk the resulting structure so | |
// that modifications can be made. | |
var k; | |
var v; | |
var value = holder[key]; | |
if (value && typeof value === "object") { | |
for (k in value) { | |
if (Object.prototype.hasOwnProperty.call(value, k)) { | |
v = walk(value, k); | |
if (v !== undefined) { | |
value[k] = v; | |
} else { | |
delete value[k]; | |
} | |
} | |
} | |
} | |
return reviver.call(holder, key, value); | |
} | |
// Parsing happens in four stages. In the first stage, we replace certain | |
// Unicode characters with escape sequences. JavaScript handles many characters | |
// incorrectly, either silently deleting them, or treating them as line endings. | |
text = String(text); | |
rx_dangerous.lastIndex = 0; | |
if (rx_dangerous.test(text)) { | |
text = text.replace(rx_dangerous, function (a) { | |
return ( | |
"\u" | |
+ ("0000" + a.charCodeAt(0).toString(16)).slice(-4) | |
); | |
}); | |
} | |
// In the second stage, we run the text against regular expressions that look | |
// for non-JSON patterns. We are especially concerned with "()" and "new" | |
// because they can cause invocation, and "=" because it can cause mutation. | |
// But just to be safe, we want to reject all unexpected forms. | |
// We split the second stage into 4 regexp operations in order to work around | |
// crippling inefficiencies in IE‘s and Safari‘s regexp engines. First we | |
// replace the JSON backslash pairs with "@" (a non-JSON character). Second, we | |
// replace all simple value tokens with "]" characters. Third, we delete all | |
// open brackets that follow a colon or comma or that begin the text. Finally, | |
// we look to see that the remaining characters are only whitespace or "]" or | |
// "," or ":" or "{" or "}". If that is so, then the text is safe for eval. | |
if ( | |
rx_one.test( | |
text | |
.replace(rx_two, "@") | |
.replace(rx_three, "]") | |
.replace(rx_four, "") | |
) | |
) { | |
// In the third stage we use the eval function to compile the text into a | |
// JavaScript structure. The "{" operator is subject to a syntactic ambiguity | |
// in JavaScript: it can begin a block or an object literal. We wrap the text | |
// in parens to eliminate the ambiguity. | |
j = eval("(" + text + ")"); | |
// In the optional fourth stage, we recursively walk the new structure, passing | |
// each name/value pair to a reviver function for possible transformation. | |
return (typeof reviver === "function") | |
? walk({"": j}, "") | |
: j; | |
} | |
// If the text is not JSON parseable, then a SyntaxError is thrown. | |
throw new SyntaxError("JSON.parse"); | |
}; | |
} | |
}()); |
以上是关于标记在IE8以下时使用JSON.stringify报JSON未定义错误的问题的主要内容,如果未能解决你的问题,请参考以下文章
JSON.stringify(Data) 在IE8 里面不可用
在没有序列化程序的对象上使用 JSON.stringify 需要标记为实验性
解决JSON.stringify()自动将中文转译成unicode的方法