带有Prototype.js的JSON.stringify（）数组异常

我试图找出json序列化出了什么问题，将我的应用程序的当前版本与旧版本一起使用，并发现JSON.stringify（）的工作方式中存在一些令人惊讶的差异（使用json.org中的JSON库） ）。

在我的应用的旧版本中：

 JSON.stringify({"a":[1,2]})

给我这个

"{\"a\":[1,2]}"

在新版本中，

 JSON.stringify({"a":[1,2]})

给我这个

"{\"a\":\"[1, 2]\"}"

任何想法都可能会发生什么变化，以使同一库在新版本中将引号放在数组括号内？

由于JSON.stringify最近已随某些浏览器一起提供，我建议使用它而不是Prototype的toJSON。然后，您将检查window.JSON && window.JSON.stringify，否则仅包含json.org库（通过document.createElement('script')…）。要解决不兼容问题，请使用：

if(window.Prototype) {
    delete Object.prototype.toJSON;
    delete Array.prototype.toJSON;
    delete Hash.prototype.toJSON;
    delete String.prototype.toJSON;
}

在ECMAScript 5及更高版本（第201页 -JSON 对象，伪代码第205页）中定义的函数JSON.stringify（）在对象上可用时使用toJSON（）函数。

由于Prototype.js（或您正在使用的另一个库）定义了Array.prototype.toJSON（）函数，因此首先使用Array.prototype.toJSON（）将数组转换为字符串，然后使用JSON.stringify（）引用字符串，因此数组周围的引号不正确。

因此，该解决方案简单明了（这是Raphael Schweikert的答案的简化版本）：

delete Array.prototype.toJSON

当然，这会对依赖toJSON（）函数属性作为数组的库产生副作用。但是考虑到与ECMAScript 5的不兼容，我发现这是一个小麻烦。

必须注意，ECMAScript 5中定义的JSON对象已在现代浏览器中有效实现，因此最好的解决方案是符合标准并修改现有库。

不会影响其他Prototype依赖关系的可能解决方案是：

var _json_stringify = JSON.stringify;
JSON.stringify = function(value) {
    var _array_tojson = Array.prototype.toJSON;
    delete Array.prototype.toJSON;
    var r=_json_stringify(value);
    Array.prototype.toJSON = _array_tojson;
    return r;
};

这样可以解决Array toJSON与JSON.stringify不兼容的问题，并保留toJSON功能，因为其他Prototype库可能依赖于此。

编辑以使其更加准确：

代码的问题关键点位于JSON.org（和ECMAScript 5的JSON对象的其他实现）的JSON库中：

if (value && typeof value === 'object' &&
  typeof value.toJSON === 'function') {
  value = value.toJSON(key);
}

问题在于Prototype库将Array扩展为包括toJSON方法，该JSON对象将在上面的代码中调用该方法。当JSON对象达到数组值时，它将在Prototype中定义的数组上调用toJSON，该方法将返回该数组的字符串版本。因此，用引号引起来。

如果您从Array对象中删除toJSON，则JSON库应该可以正常工作。或者，只需使用JSON库。

我认为更好的解决方案是在原型加载后立即添加

JSON = JSON || {};

JSON.stringify = function(value) { return value.toJSON(); };

JSON.parse = JSON.parse || function(jsonsring) { return jsonsring.evalJSON(true); };

这使原型函数可以作为标准JSON.stringify（）和JSON.parse（）使用，但是保留了本地JSON.parse（）（如果可用），因此这使它们与较旧的浏览器更加兼容。

我对Prototype不太熟练，但是我在其docs中看到了这一点：

Object.toJSON({"a":[1,2]})

我不确定这是否会与当前编码有相同的问题。

还有关于使用JSON与Prototype 的更长的教程。

这是我用于相同问题的代码：

function stringify(object){
      var Prototype = window.Prototype
      if (Prototype && Prototype.Version < '1.7' &&
          Array.prototype.toJSON && Object.toJSON){
              return Object.toJSON(object)
      }
      return JSON.stringify(object)
}

您检查原型是否存在，然后检查版本。如果旧版本在所有其他情况下都使用Object.toJSON（如果已定义），则退回到JSON.stringify（）

这就是我的处理方式。

var methodCallString =  Object.toJSON? Object.toJSON(options.jsonMethodCall) :  JSON.stringify(options.jsonMethodCall);

我的宽容解决方案检查Array.prototype.toJSON是否对JSON字符串化有害，并在可能的情况下保留它，以使周围的代码按预期工作：

var dummy = { data: [{hello: 'world'}] }, test = {};

if(Array.prototype.toJSON) {
    try {
        test = JSON.parse(JSON.stringify(dummy));
        if(!test || dummy.data !== test.data) {
            delete Array.prototype.toJSON;
        }
    } catch(e) {
        // there only hope
    }
}

正如人们所指出的，这是由于Prototype.js所致-特别是1.7之前的版本。我也有类似的情况，但是无论是否有Prototype.js，都必须有运行代码。这意味着我不能删除Array.prototype.toJSON，因为我不确定它依赖什么。对于这种情况，这是我想出的最佳解决方案：

function safeToJSON(item){ 
    if ([1,2,3] === JSON.parse(JSON.stringify([1,2,3]))){
        return JSON.stringify(item); //sane behavior
    } else { 
        return item.toJSON(); // Prototype.js nonsense
    }
}

希望它将对某人有所帮助。

如果您不想杀死所有内容，并且拥有在大多数浏览器上都可以使用的代码，则可以这样操作：

(function (undefined) { // This is just to limit _json_stringify to this scope and to redefine undefined in case it was
  if (true ||typeof (Prototype) !== 'undefined') {
    // First, ensure we can access the prototype of an object.
    // See http://stackoverflow.com/questions/7662147/how-to-access-object-prototype-in-javascript
    if(typeof (Object.getPrototypeOf) === 'undefined') {
      if(({}).__proto__ === Object.prototype && ([]).__proto__ === Array.prototype) {
        Object.getPrototypeOf = function getPrototypeOf (object) {
          return object.__proto__;
        };
      } else {
        Object.getPrototypeOf = function getPrototypeOf (object) {
          // May break if the constructor has been changed or removed
          return object.constructor ? object.constructor.prototype : undefined;
        }
      }
    }

    var _json_stringify = JSON.stringify; // We save the actual JSON.stringify
    JSON.stringify = function stringify (obj) {
      var obj_prototype = Object.getPrototypeOf(obj),
          old_json = obj_prototype.toJSON, // We save the toJSON of the object
          res = null;
      if (old_json) { // If toJSON exists on the object
        obj_prototype.toJSON = undefined;
      }
      res = _json_stringify.apply(this, arguments);
      if (old_json)
        obj_prototype.toJSON = old_json;
      return res;
    };
  }
}.call(this));

这似乎很复杂，但这仅适用于处理大多数用例。主要思想是重写从作为参数传递的对象中JSON.stringify删除toJSON，然后调用old JSON.stringify，最后将其还原。