标记在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 "&nbsp;"),
  // 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 需要标记为实验性

IE 8 支持 JSON.stringify() 吗?

解决JSON.stringify()自动将中文转译成unicode的方法

jQuery解决IE6、7、8不能使用 JSON.stringify 函数的问题

JSON对象的解析,JSON.stringify()/JSON.parse()的用法