blocks|key|1590768|text|以下是我处理它的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1590769|var+methodCallString+=++Object.toJSON?+Object.toJSON(options.jsonMethodCall)+:++JSON.stringify(options.jsonMethodCall);|code-block|syntax|javascript|1590770|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's how I'm dealing with it.

<pre><code>var methodCallString = Object.toJSON? Object.toJSON(options.jsonMethodCall) : JSON.stringify(options.jsonMethodCall);
</code></pre>

blocks|key|1590832|text|我对原型不太熟悉，但我在它的docs中看到了这一点|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1590833|Object.toJSON({"a":[1,2]})|code-block|syntax|javascript|1590834|不过，我不确定这是否会有与当前编码相同的问题。|1590835|在Prototype中使用JSON还有一个更长的tutorial。|1590836|entityMap|0|LINK|mutability|MUTABLE|url|http://www.prototypejs.org/api/object/toJSON|1|http://www.prototypejs.org/learn/json^0|E|4|0|0|0|0|O|8|1|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]]]

I'm not that fluent with Prototype, but I saw this in its <a href="http://www.prototypejs.org/api/object/toJSON" rel="nofollow noreferrer">docs</a>:

<pre><code>Object.toJSON({"a":[1,2]})
</code></pre>

I'm not sure if this would have the same problem the current encoding has, though.

There's also a longer <a href="http://www.prototypejs.org/learn/json" rel="nofollow noreferrer">tutorial</a> about using JSON with Prototype.

blocks|key|1375613|text|我认为更好的解决方案是在原型加载后立即包含此内容。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1375614|JSON+=+JSON+%7C%7C+{};

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

JSON.parse+=+JSON.parse+%7C%7C+function(jsonsring)+{+return+jsonsring.evalJSON(true);+};|code-block|syntax|javascript|1375615|这使得原型函数可用作标准的JSON.stringify()和JSON.parse()，但保留本机JSON.parse()+(如果可用)，因此这使其与较旧的浏览器更兼容。|1375616|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I think a better solution would be to include this just after prototype has been loaded

<pre><code>JSON = JSON || {};

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

JSON.parse = JSON.parse || function(jsonsring) { return jsonsring.evalJSON(true); };
</code></pre>

This makes the prototype function available as the standard JSON.stringify() and JSON.parse(), but keeps the native JSON.parse() if it is available, so this makes things more compatible with older browsers.

blocks|key|1591010|text|编辑以使其更准确：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1591011|问题的关键代码在JSON.org的JSON库中(以及ECMAScript+5的JSON对象的其他实现)：|1591012|if+(value+&&+typeof+value+===+'object'+&&
++typeof+value.toJSON+===+'function')+{
++value+=+value.toJSON(key);
}|code-block|syntax|javascript|1591013|问题是Prototype库扩展了数组以包含一个toJSON方法，JSON对象将在上面的代码中调用该方法。当JSON对象命中数组值时，它在Prototype中定义的数组上调用toJSON，该方法返回数组的字符串版本。因此，数组括号周围的引号。|1591014|如果从数组对象中删除toJSON，JSON库应该可以正常工作。或者，只使用JSON库。|1591015|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Edit to make a bit more accurate:

The problem key bit of code is in the JSON library from JSON.org (and other implementations of ECMAScript 5's JSON object):

<pre><code>if (value &amp;&amp; typeof value === 'object' &amp;&amp;
 typeof value.toJSON === 'function') {
 value = value.toJSON(key);
}
</code></pre>

The problem is that the Prototype library extends Array to include a toJSON method, which the JSON object will call in the code above. When the JSON object hits the array value it calls toJSON on the array which is defined in Prototype, and that method returns a string version of the array. Hence, the quotes around the array brackets.

If you delete toJSON from the Array object the JSON library should work properly. Or, just use the JSON library.

blocks|key|1591165|text|由于JSON.stringify最近在一些浏览器上发布，我建议使用它而不是Prototype的toJSON。然后检查window.JSON+&&+window.JSON.stringify，否则只包含json.org库(通过document.createElement('script')…)。要解决不兼容问题，请使用：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1591166|if(window.Prototype)+{
++++delete+Object.prototype.toJSON;
++++delete+Array.prototype.toJSON;
++++delete+Hash.prototype.toJSON;
++++delete+String.prototype.toJSON;
}|code-block|syntax|javascript|1591167|entityMap^0|34|W|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Since JSON.stringify has been shipping with some browsers lately, I would suggest using it instead of Prototype’s toJSON. You would then check for window.JSON &amp;&amp; window.JSON.stringify and only include the json.org library otherwise (via <code>document.createElement('script')</code>…). To resolve the incompatibilities, use:

<pre><code>if(window.Prototype) {
 delete Object.prototype.toJSON;
 delete Array.prototype.toJSON;
 delete Hash.prototype.toJSON;
 delete String.prototype.toJSON;
}
</code></pre>

blocks|key|1591310|text|在ECMAScript+5+and+above+(Page+201+-+the+JSON+Object,+pseudo-code+Page+205)中定义的函数JSON.stringify()在对象上可用时使用函数toJSON()。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1591311|由于Prototype.js+(或您正在使用的另一个库)定义了一个Array.prototype.toJSON()函数，因此首先使用Array.prototype.toJSON()将数组转换为字符串，然后使用JSON.stringify()引用string，从而导致数组两边出现错误的额外引号。|1591312|因此，解决方案简单明了(这是拉斐尔·施韦克特答案的简化版本)：|1591313|delete+Array.prototype.toJSON|code-block|syntax|javascript|1591314|这当然会对依赖数组的toJSON()函数属性的库产生副作用。但考虑到与ECMAScript+5的不兼容性，我发现这是一个小小的不便。|1591315|必须注意的是，在JSON5中定义的ECMAScript对象在现代浏览器中得到了有效的实现，因此最好的解决方案是遵循标准并修改现有的库。|1591316|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262%2520edition%25205.1,%2520June%25202011.pdf^0|1|21|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|13|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|14|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|C|$]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

The function JSON.stringify() defined in <a href="http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262%20edition%205.1,%20June%202011.pdf" rel="noreferrer">ECMAScript 5 and above (Page 201 - the JSON Object, pseudo-code Page 205)</a>, uses the function toJSON() when available on objects.

Because Prototype.js (or another library that you are using) defines an Array.prototype.toJSON() function, arrays are first converted to strings using Array.prototype.toJSON() then string quoted by JSON.stringify(), hence the incorrect extra quotes around the arrays.

The solution is therefore straight-forward and trivial (this is a simplified version of Raphael Schweikert's answer):

<pre><code>delete Array.prototype.toJSON
</code></pre>

This produces of course side effects on libraries that rely on a toJSON() function property for arrays. But I find this a minor inconvenience considering the incompatibility with ECMAScript 5.

It must be noted that the JSON Object defined in ECMAScript 5 is efficiently implemented in modern browsers and therefore the best solution is to conform to the standard and modify existing libraries.

blocks|key|1376078|text|我的容错解决方案检查Array.prototype.toJSON是否对JSON+stringify有害，并在可能的情况下保留它，以便让周围的代码按预期工作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1376079|var+dummy+=+{+data:+[{hello:+'world'}]+},+test+=+{};

if(Array.prototype.toJSON)+{
++++try+{
++++++++test+=+JSON.parse(JSON.stringify(dummy));
++++++++if(!test+%7C%7C+dummy.data+!==+test.data)+{
++++++++++++delete+Array.prototype.toJSON;
++++++++}
++++}+catch(e)+{
++++++++//+there+only+hope
++++}
}|code-block|syntax|javascript|1376080|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

My tolerant solution checks whether Array.prototype.toJSON is harmful for JSON stringify and keeps it when possible to let the surrounding code work as expected:

<pre><code>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
 }
}
</code></pre>

blocks|key|1376162|text|正如人们所指出的，这是由于Prototype.js+-特别是1.7之前的版本。我遇到过类似的情况，但无论Prototype.js是否存在，都必须有代码来操作；这意味着我不能简单地删除Array.prototype.toJSON，因为我不确定依赖它的是什么。对于这种情况，这是我想出的最好的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1376163|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
++++}
}|code-block|syntax|javascript|1376164|希望它能帮助一些人。|1376165|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

As people have pointed out, this is due to Prototype.js - specifically versions prior to 1.7. I had a similar situation but had to have code that operated whether Prototype.js was there or not; this means I can't just delete the Array.prototype.toJSON as I'm not sure what relies on it. For that situation this is the best solution I came up with:

<pre><code>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
 }
}
</code></pre>

Hopefully it will help someone.

blocks|key|1591513|text|一种不会影响其他原型依赖关系的可能解决方案是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1591514|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;
};|code-block|syntax|javascript|1591515|这解决了阵列toJSON与JSON.stringify不兼容的问题，还保留了toJSON功能，因为其他原型库可能会依赖它。|1591516|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

A possible solution which will not affect other Prototype dependencies would be:

<pre><code>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;
};
</code></pre>

This takes care of the Array toJSON incompatibility with JSON.stringify and also retains toJSON functionality as other Prototype libraries may depend on it.

blocks|key|1591570|text|如果你不想杀死所有的东西，并且有一个在大多数浏览器上都可以的代码，你可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1591571|(function+(undefined)+{+//+This+is+just+to+limit+_json_stringify+to+this+scope+and+to+redefine+undefined+in+case+it+was
++if+(true+%7C%7Ctypeof+(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));|code-block|syntax|javascript|1591572|这看起来很复杂，但只有在处理大多数用例时才是复杂的。主要思想是覆盖JSON.stringify，从作为参数传递的对象中删除toJSON，然后调用旧的JSON.stringify，最后恢复它。|offset|length|style|CODE|1591573|entityMap^0|0|0|X|E|1P|6|22|E|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|N|$]]

If you don't want to kill everything, and have a code that would be okay on most browsers, you could do it this way :

<pre><code>(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 &amp;&amp; ([]).__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));
</code></pre>

This seems complex, but this is complex only to handle most use cases.
The main idea is overriding <code>JSON.stringify</code> to remove <code>toJSON</code> from the object passed as an argument, then call the old <code>JSON.stringify</code>, and finally restore it.

blocks|key|1591630|text|这是我用来解决相同问题的代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1591631|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)
}|code-block|syntax|javascript|1591632|你先检查原型是否存在，然后再检查版本。如果旧版本在所有其他情况下使用Object.toJSON+(如果已定义)，则回退到JSON.stringify()|1591633|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

This is the code I used for the same issue:

<pre><code>function stringify(object){
 var Prototype = window.Prototype
 if (Prototype &amp;&amp; Prototype.Version &lt; '1.7' &amp;&amp;
 Array.prototype.toJSON &amp;&amp; Object.toJSON){
 return Object.toJSON(object)
 }
 return JSON.stringify(object)
}
</code></pre>

You check if Prototype exists, then you check the version. If old version use Object.toJSON (if is defined) in all other cases fallback to JSON.stringify()

I'm trying to figure out what's gone wrong with my json serializing, have the current version of my app with and old one and am finding some surprising differences in the way JSON.stringify() works (Using the JSON library from json.org).

In the old version of my app:

<pre><code> JSON.stringify({"a":[1,2]})
</code></pre>

gives me this;

<pre><code>"{\"a\":[1,2]}"
</code></pre>

in the new version, 

<pre><code> JSON.stringify({"a":[1,2]})
</code></pre>

gives me this;

<pre><code>"{\"a\":\"[1, 2]\"}"
</code></pre>

any idea what could have changed to make the same library put quotes around the array brackets in the new version?

JSON.stringify() array bizarreness with Prototype.js

JSON

我试图找出我的json序列化出了什么问题，让我的应用程序的最新版本和旧版本存在一些令人惊讶的差异(使用来自json.org的JSON库) JSON.stringify()的工作方式。在我的旧版本应用中： JSON.stringify({"a":[1,2]})给了我这个；"{\"a\":[1,2]}"在新版本中， JSO...

问Prototype.js中的JSON.stringify()数组奇异性
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Prototype.js中的JSON.stringify()数组奇异性EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Prototype.js中的JSON.stringify()数组奇异性
EN