blocks|key|235384|text|使用stringify的第二个参数replacer+function来排除已经序列化的对象：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|235385|var+seen+=+[];

JSON.stringify(obj,+function(key,+val)+{
+++if+(val+!=+null+&&+typeof+val+==+"object")+{
++++++++if+(seen.indexOf(val)+>=+0)+{
++++++++++++return;
++++++++}
++++++++seen.push(val);
++++}
++++return+val;
});|code-block|syntax|javascript|235386|http://jsfiddle.net/mH6cJ/38/|235387|正如在其他注释中正确指出的那样，此代码删除了每个“可见”对象，而不仅仅是“递归”对象。|235388|例如，对于：|235389|a+=+{x:1};
obj+=+[a,+a];|235390|结果将是不正确的。如果你的结构是这样的，你可能想要使用克罗克福德的decycle或者这个(更简单的)函数，它只是将递归引用替换为null：|235391|​|235392|function+decycle(obj,+stack+=+[])+{
++++if+(!obj+%7C%7C+typeof+obj+!==+'object')
++++++++return+obj;
++++
++++if+(stack.includes(obj))
++++++++return+null;

++++let+s+=+stack.concat([obj]);

++++return+Array.isArray(obj)
++++++++?+obj.map(x+=>+decycle(x,+s))
++++++++:+Object.fromEntries(
++++++++++++Object.entries(obj)
++++++++++++++++.map(([k,+v])+=>+[k,+decycle(v,+s)]));
}

//

let+a+=+{b:+[1,+2,+3]}
a.b.push(a);

console.log(JSON.stringify(decycle(a)))|235393|235394|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#The_replacer_parameter|1|2|https://github.com/douglascrockford/JSON-js/blob/master/cycle.js^0|2|9|H|H|0|0|0|0|T|1|0|0|0|0|X|7|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@$9|1B|A|1C|B|C]]|D|@$9|1D|A|1E|1|1F]]|E|$]]|$1|F|3|G|5|H|7|1G|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1H|8|@]|D|@$9|1I|A|1J|1|1K]]|E|$]]|$1|M|3|N|5|6|7|1L|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1M|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1N|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1O|8|@]|D|@$9|1P|A|1Q|1|1R]]|E|$]]|$1|U|3|V|5|6|7|1S|8|@]|D|@]|E|$]]|$1|W|3|X|5|H|7|1T|8|@]|D|@]|E|$I|J]]|$1|Y|3|V|5|6|7|1U|8|@]|D|@]|E|$]]|$1|Z|3|-4|5|6|7|1V|8|@]|D|@]|E|$]]]|10|$11|$5|12|13|14|E|$15|16]]|17|$5|12|13|14|E|$15|L]]|18|$5|12|13|14|E|$15|19]]]]

Use the second parameter of <code>stringify</code>, the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#The_replacer_parameter" rel="noreferrer">replacer function</a>, to exclude already serialized objects:

<pre><code>var seen = [];

JSON.stringify(obj, function(key, val) {
 if (val != null &amp;&amp; typeof val == "object") {
 if (seen.indexOf(val) &gt;= 0) {
 return;
 }
 seen.push(val);
 }
 return val;
});
</code></pre>

<a href="http://jsfiddle.net/mH6cJ/38/" rel="noreferrer">http://jsfiddle.net/mH6cJ/38/</a>

As correctly pointed out in other comments, this code removes every "seen" object, not only "recursive" ones. 

For example, for:

<pre><code>a = {x:1};
obj = [a, a];
</code></pre>

the result will be incorrect. If your structure is like this, you might want to use Crockford's <a href="https://github.com/douglascrockford/JSON-js/blob/master/cycle.js" rel="noreferrer">decycle</a> or this (simpler) function which just replaces recursive references with nulls:

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function decycle(obj, stack = []) {
 if (!obj || typeof obj !== 'object')
 return obj;
 
 if (stack.includes(obj))
 return null;

 let s = stack.concat([obj]);

 return Array.isArray(obj)
 ? obj.map(x =&gt; decycle(x, s))
 : Object.fromEntries(
 Object.entries(obj)
 .map(([k, v]) =&gt; [k, decycle(v, s)]));
}

//

let a = {b: [1, 2, 3]}
a.b.push(a);

console.log(JSON.stringify(decycle(a)))</code></pre>
</div>
</div>

blocks|key|237963|text|节省了很多，它显示了cycle对象的位置。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|237964|<script>
var+jsonify=function(o){
++++var+seen=[];
++++var+jso=JSON.stringify(o,+function(k,v){
++++++++if+(typeof+v+=='object')+{
++++++++++++if+(+!seen.indexOf(v)+)+{+return+'__cycle__';+}
++++++++++++seen.push(v);
++++++++}+return+v;
++++});
++++return+jso;
};
var+obj={
++++g:{
++++++++d:[2,5],
++++++++j:2
++++},
++++e:10
};
obj.someloopshere+=+[
++++obj.g,
++++obj,
++++{+a:+[+obj.e,+obj+]+}
];
console.log('jsonify=',jsonify(obj));
</script>|code-block|syntax|javascript|237965|产生|237966|jsonify+=+{"g":{"d":[2,5],"j":2},"e":10,"someloopshere":[{"d":[2,5],"j":2},"__cycle__",{"a":[10,"__cycle__"]}]}|237967|entityMap^0|A|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

much saver and it shows where an cycle object was.

<pre><code>&lt;script&gt;
var jsonify=function(o){
 var seen=[];
 var jso=JSON.stringify(o, function(k,v){
 if (typeof v =='object') {
 if ( !seen.indexOf(v) ) { return '__cycle__'; }
 seen.push(v);
 } return v;
 });
 return jso;
};
var obj={
 g:{
 d:[2,5],
 j:2
 },
 e:10
};
obj.someloopshere = [
 obj.g,
 obj,
 { a: [ obj.e, obj ] }
];
console.log('jsonify=',jsonify(obj));
&lt;/script&gt;
</code></pre>

produces

<pre><code>jsonify = {"g":{"d":[2,5],"j":2},"e":10,"someloopshere":[{"d":[2,5],"j":2},"__cycle__",{"a":[10,"__cycle__"]}]}
</code></pre>

blocks|key|3119152|text|我已经创建了一个GitHub+Gist，它能够检测循环结构，还可以对它们进行解码和编码：https://gist.github.com/Hoff97/9842228|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3119153|要进行转换，只需使用JSONE.stringify/JSONE.parse。它还对函数进行解压和编码。如果要禁用此功能，只需删除第32-48行和第61-85行。|3119154|var+strg+=+JSONE.stringify(cyclicObject);
var+cycObject+=+JSONE.parse(strg);|code-block|syntax|javascript|3119155|你可以在这里找到一个小提琴示例：|3119156|http://jsfiddle.net/hoff97/7UYd4/|3119157|entityMap|0|LINK|mutability|MUTABLE|url|https://gist.github.com/Hoff97/9842228|1^0|18|12|0|0|0|0|0|0|X|1|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@$A|Y|B|Z|1|10]]|C|$]]|$1|D|3|E|5|6|7|11|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|12|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|13|8|@]|9|@]|C|$]]|$1|M|3|N|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]]|C|$]]|$1|O|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]|W|$5|R|S|T|C|$U|N]]]]

I've created an GitHub Gist which is able to detect cyclic structures and also de- and encodes them: <a href="https://gist.github.com/Hoff97/9842228" rel="nofollow">https://gist.github.com/Hoff97/9842228</a>

To transform just use JSONE.stringify/JSONE.parse.
It also de- and encodes functions. If you want to disable this just remove lines 32-48 and 61-85.

<pre><code>var strg = JSONE.stringify(cyclicObject);
var cycObject = JSONE.parse(strg);
</code></pre>

You can find an example fiddle here:

<a href="http://jsfiddle.net/hoff97/7UYd4/" rel="nofollow">http://jsfiddle.net/hoff97/7UYd4/</a>

blocks|key|240835|text|function+stringifyObject+(+obj+)+{
++if+(+_.isArray(+obj+)+%7C%7C+!_.isObject(+obj+)+)+{
++++return+obj.toString()
++}
++var+seen+=+[];
++return+JSON.stringify(
++++obj,
++++function(+key,+val+)+{
++++++if+(val+!=+null+&&+typeof+val+==+"object")+{
++++++++if+(+seen.indexOf(+val+)+>=+0+)
++++++++++return
++++++++++seen.push(+val+)
++++++++++}
++++++return+val
++++}
++);
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|240836|缺少前提条件，否则数组对象中的整数值将被截断，即[+08.11.2014+12:30:13,1095+]+1095将减少为095。|unstyled|240837|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>function stringifyObject ( obj ) {
 if ( _.isArray( obj ) || !_.isObject( obj ) ) {
 return obj.toString()
 }
 var seen = [];
 return JSON.stringify(
 obj,
 function( key, val ) {
 if (val != null &amp;&amp; typeof val == "object") {
 if ( seen.indexOf( val ) &gt;= 0 )
 return
 seen.push( val )
 }
 return val
 }
 );
}
</code></pre>

A precondition was missing, otherwise the integer values in array objects are truncated, i.e. [[ 08.11.2014 12:30:13, 1095 ]] 1095 gets reduced to 095.

blocks|key|235440|text|我也创建了一个github项目，它可以序列化循环对象，如果您将它像字符串一样保存在serializename属性中，还可以恢复类|type|unstyled|depth|inlineStyleRanges|entityRanges|data|235441|var+d={}
var+a+=+{b:25,c:6,enfant:d};
d.papa=a;
var+b+=+serializeObjet(a);
assert.equal(++b,+"{0:{b:25,c:6,enfant:'tab[1]'},1:{papa:'tab[0]'}}"+);
var+retCaseDep+=+parseChaine(b)
assert.equal(++retCaseDep.b,+25+);
assert.equal(++retCaseDep.enfant.papa,+retCaseDep+);|code-block|syntax|javascript|235442|https://github.com/bormat/serializeStringifyParseCyclicObject|offset|length|235443|编辑:我已经转换了我的NPM+https://github.com/bormat/borto_circular_serialize的脚本，我已经将函数名从法语改为英语。|235444|entityMap|0|LINK|mutability|MUTABLE|url|1|https://github.com/bormat/borto_circular_serialize^0|0|0|0|1P|0|0|F|1E|1|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|W|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|X|8|@]|9|@$I|Y|J|Z|1|10]]|A|$]]|$1|K|3|L|5|6|7|11|8|@]|9|@$I|12|J|13|1|14]]|A|$]]|$1|M|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|H]]|T|$5|P|Q|R|A|$S|U]]]]

I create too a github project that can serialize cyclic object and restore the class if you save it in the serializename attribute like a String 

<pre><code>var d={}
var a = {b:25,c:6,enfant:d};
d.papa=a;
var b = serializeObjet(a);
assert.equal( b, "{0:{b:25,c:6,enfant:'tab[1]'},1:{papa:'tab[0]'}}" );
var retCaseDep = parseChaine(b)
assert.equal( retCaseDep.b, 25 );
assert.equal( retCaseDep.enfant.papa, retCaseDep );
</code></pre>

<a href="https://github.com/bormat/serializeStringifyParseCyclicObject" rel="nofollow noreferrer">https://github.com/bormat/serializeStringifyParseCyclicObject</a>

Edit: 
 I have transform my script for NPM <a href="https://github.com/bormat/borto_circular_serialize" rel="nofollow noreferrer">https://github.com/bormat/borto_circular_serialize</a> and I have change function names from french to english.

blocks|key|235494|text|下面是一个具有循环引用的数据结构示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|235495|📷|atomic|offset|length|235496|​|235497|function+makeToolshed(){
++++var+nut+=+{name:+'nut'},+bolt+=+{name:+'bolt'};
++++nut.needs+=+bolt;+bolt.needs+=+nut;
++++return+{+nut:+nut,+bolt:+bolt+};
}|code-block|syntax|javascript|235498|当你想保持循环引用()(在反序列化时恢复它们，而不是“‘ll”它们)，你有两个选择，我将在这里进行比较。首先是Douglas+Crockford的cycle.js，其次是我的siberia包。两者的工作方式都是首先“解循环”对象，即构造“包含相同信息”的另一个对象(没有任何循环引用)。|235499|克罗克福德先生先说：|235500|JSON.decycle(makeToolshed())|235501|235502|235503|235504|如您所见，JSON的嵌套结构保持不变，但有了一个新东西，即具有特殊$ref属性的对象。让我们看看它是如何工作的。|style|CODE|235505|root+=+makeToolshed();
[root.bolt+===+root.nut.needs,+root.nut.needs.needs+===+root.nut];+//+retutrns+[true,true]|235506|美元符号代表词根。具有$ref的坚果告诉我们.bolt是一个“已经看到”的对象，而这个特殊属性的值(这里是字符串$“.bolt”)告诉我们在哪里，请参见上面的第一个===。上面的第二个$ref和第二个===也是如此。|235507|让我们使用合适的深度相等性测试(即Anders+Kaseorg对this+question的公认答案中的deepGraphEqual函数)来查看克隆是否有效。|235508|root+=+makeToolshed();
clone+=+JSON.retrocycle(JSON.decycle(root));
deepGraphEqual(root,+clone)+//+true
serialized+=+JSON.stringify(JSON.decycle(root));
clone2+=+JSON.retrocycle(JSON.parse(serialized));
deepGraphEqual(root,+clone2);+//+true|235509|现在，西伯利亚：|235510|JSON.Siberia.forestify(makeToolshed())|235511|235512|235513|235514|西伯利亚没有试图模仿“经典”的JSON，没有嵌套结构。对象图是以“扁平”的方式描述的。对象图的每个节点都被转换成一个扁平树(纯键值对列表，它是.forest.中索引为0的条目)，我们找到根对象，在更高的索引中，我们找到对象图的其他节点，负值(森林的某些树的某个键的负值)指向atoms数组(它是通过类型数组键入的，但我们在这里跳过键入的细节)。所有终端节点都在atoms表中，所有非终端节点都在森林表中，您可以立即看到对象图有多少个节点，即forest.length。让我们测试一下它是否正常工作：|235515|root+=+makeToolshed();
clone+=+JSON.Siberia.unforestify(JSON.Siberia.forestify(root));
deepGraphEqual(root,+clone);+//+true
serialized+=+JSON.Siberia.stringify(JSON.Siberia.forestify(root));
clone2+=+JSON.Siberia.unforestify(JSON.Siberia.unstringify(serialized));
deepGraphEqual(root,+clone2);+//+true|235516|比较|235517|稍后将添加部分。|235518|备注|235519|我现在正在重构这个包。核心思想和算法保持不变，但新版本将更容易使用，顶级API将有所不同。我很快就会对西伯利亚进行归档，并展示重构后的版本，我称之为objectgraph。敬请期待，这将在本月(2020年8月)发生。|235520|啊，还有超短版比较一下。对于“指针”，我需要一个整数占用的空间，因为我的“指向已经看到的节点的指针”(事实上，指向所有节点的指针，不管是否已经看到)都是整数。在Crockford先生的版本中，存储“指针”所需的量仅受对象图大小的限制。这使得克罗克福德的版本在最坏的情况下变得极其复杂。克罗克福德先生给了我们“另一个泡泡”。我没跟你开玩笑。真的很糟糕。如果你不相信，有一些测试，你可以从软件包的自述文件中找到它们(将在这个月，2020年8月将它们转换为benchmark.js兼容)|235521|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/6b2a96e3daf6c40a8bfe6ff6800114f2.png|imageAlt|1|LINK|MUTABLE|url|https://github.com/douglascrockford/JSON-js/blob/master/cycle.js|2|https://github.com/mathHeadInClouds/siberia|3|https://ask.qcloudimg.com/http-save/yehe-900000/d97ed74a664c712e0a6a8840210fb2a1.png|4|https://stackoverflow.com/questions/32793484/test-deep-equality-with-sharing-of-javascript-objects|5|https://ask.qcloudimg.com/http-save/yehe-900000/9ca50c0bfa5344a1a1237271aeba2090.png^0|0|0|1|0|0|0|0|21|8|1|2F|7|2|0|0|0|0|0|1|3|0|0|X|4|0|0|B|4|M|5|1M|5|2A|3|2K|4|2S|3|0|1G|E|W|D|4|0|0|0|0|0|0|1|5|0|0|1Z|8|3T|5|64|D|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|2F|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|2G|8|@]|9|@$E|2H|F|2I|1|2J]]|A|$]]|$1|G|3|H|5|6|7|2K|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|2L|8|@]|9|@]|A|$L|M]]|$1|N|3|O|5|6|7|2M|8|@]|9|@$E|2N|F|2O|1|2P]|$E|2Q|F|2R|1|2S]]|A|$]]|$1|P|3|Q|5|6|7|2T|8|@]|9|@]|A|$]]|$1|R|3|S|5|K|7|2U|8|@]|9|@]|A|$L|M]]|$1|T|3|H|5|6|7|2V|8|@]|9|@]|A|$]]|$1|U|3|C|5|D|7|2W|8|@]|9|@$E|2X|F|2Y|1|2Z]]|A|$]]|$1|V|3|H|5|6|7|30|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|31|8|@$E|32|F|33|Y|Z]]|9|@]|A|$]]|$1|10|3|11|5|K|7|34|8|@]|9|@]|A|$L|M]]|$1|12|3|13|5|6|7|35|8|@$E|36|F|37|Y|Z]|$E|38|F|39|Y|Z]|$E|3A|F|3B|Y|Z]|$E|3C|F|3D|Y|Z]|$E|3E|F|3F|Y|Z]|$E|3G|F|3H|Y|Z]]|9|@]|A|$]]|$1|14|3|15|5|6|7|3I|8|@$E|3J|F|3K|Y|Z]]|9|@$E|3L|F|3M|1|3N]]|A|$]]|$1|16|3|17|5|K|7|3O|8|@]|9|@]|A|$L|M]]|$1|18|3|19|5|6|7|3P|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|K|7|3Q|8|@]|9|@]|A|$L|M]]|$1|1C|3|H|5|6|7|3R|8|@]|9|@]|A|$]]|$1|1D|3|C|5|D|7|3S|8|@]|9|@$E|3T|F|3U|1|3V]]|A|$]]|$1|1E|3|H|5|6|7|3W|8|@]|9|@]|A|$]]|$1|1F|3|1G|5|6|7|3X|8|@$E|3Y|F|3Z|Y|Z]|$E|40|F|41|Y|Z]|$E|42|F|43|Y|Z]]|9|@]|A|$]]|$1|1H|3|1I|5|K|7|44|8|@]|9|@]|A|$L|M]]|$1|1J|3|1K|5|6|7|45|8|@]|9|@]|A|$]]|$1|1L|3|1M|5|6|7|46|8|@]|9|@]|A|$]]|$1|1N|3|1O|5|6|7|47|8|@]|9|@]|A|$]]|$1|1P|3|1Q|5|6|7|48|8|@]|9|@]|A|$]]|$1|1R|3|1S|5|6|7|49|8|@]|9|@]|A|$]]|$1|1T|3|-4|5|6|7|4A|8|@]|9|@]|A|$]]]|1U|$1V|$5|1W|1X|1Y|A|$1Z|20|21|-4]]|22|$5|23|1X|24|A|$25|26]]|27|$5|23|1X|24|A|$25|28]]|29|$5|1W|1X|1Y|A|$1Z|2A|21|-4]]|2B|$5|23|1X|24|A|$25|2C]]|2D|$5|1W|1X|1Y|A|$1Z|2E|21|-4]]]]

Here is an example of a data structure with cyclic references:
<img src="https://mathheadinclouds.github.io/img/shed.png" alt="toolshedCY" />
<pre class="lang-js prettyprint-override"><code>function makeToolshed(){
 var nut = {name: 'nut'}, bolt = {name: 'bolt'};
 nut.needs = bolt; bolt.needs = nut;
 return { nut: nut, bolt: bolt };
}
</code></pre>
When you wish to KEEP the cyclic references (restore them when you deserialize, instead of &quot;nuking&quot; them), you have 2 choices, which I'll compare here. First is Douglas Crockford's <a href="https://github.com/douglascrockford/JSON-js/blob/master/cycle.js" rel="nofollow noreferrer">cycle.js</a>, second is my <a href="https://github.com/mathHeadInClouds/siberia" rel="nofollow noreferrer">siberia</a> package. Both work by first &quot;decycling&quot; the object, i.e., constructing another object (without any cyclic references) &quot;containing the same information.&quot;
Mr. Crockford goes first:
<pre><code>JSON.decycle(makeToolshed())
</code></pre>
<img src="https://mathheadinclouds.github.io/img/JSON_decycleMakeToolshed.png" alt="JSON_decycleMakeToolshed" />
As you see, the nested structure of JSON is retained, but there is a new thing, which is objects with the special <code>$ref</code> property. Let's see how that works.
<pre><code>root = makeToolshed();
[root.bolt === root.nut.needs, root.nut.needs.needs === root.nut]; // retutrns [true,true]
</code></pre>
The dollar sign stands for the root. <code>.bolt</code> having <code>$ref</code> tells us that <code>.bolt</code> is an &quot;already seen&quot; object, and the value of that special property (here, the string $[&quot;nut&quot;][&quot;needs&quot;]) tells us where, see first <code>===</code> above. Likewise for second <code>$ref</code> and the second <code>===</code> above.
Let's use a suitable deep equality test (namely Anders Kaseorg's <code>deepGraphEqual</code> function from accepted answer to <a href="https://stackoverflow.com/questions/32793484/test-deep-equality-with-sharing-of-javascript-objects">this question</a>) to see if cloning works.
<pre><code>root = makeToolshed();
clone = JSON.retrocycle(JSON.decycle(root));
deepGraphEqual(root, clone) // true
serialized = JSON.stringify(JSON.decycle(root));
clone2 = JSON.retrocycle(JSON.parse(serialized));
deepGraphEqual(root, clone2); // true
</code></pre>
Now, siberia:
<pre><code>JSON.Siberia.forestify(makeToolshed())
</code></pre>
<img src="https://mathheadinclouds.github.io/img/JSON_Siberia_forestify_makeToolshed.png" alt="JSON_Siberia_forestify_makeToolshed" />
Siberia does not try to mimic &quot;classic&quot; JSON, no nested structure. The object graph is described in a &quot;flat&quot; manner.
Each node of the object graph is turned into a flat tree (plain key value pair list with integer-only values), which is an entry in <code>.forest.</code> At index zero, we find the root object, at higher indices, we find the other nodes of the object graph, and negative values (of some key of some tree of the forest) point to the <code>atoms</code> array, (which is typed via the types array, but we'll skip the typing details here). All terminal nodes are in the atoms table, all non-terminal nodes are in the forest table, and you can see right away how many nodes the object graph has, namely <code>forest.length</code>. Let's test if it works:
<pre><code>root = makeToolshed();
clone = JSON.Siberia.unforestify(JSON.Siberia.forestify(root));
deepGraphEqual(root, clone); // true
serialized = JSON.Siberia.stringify(JSON.Siberia.forestify(root));
clone2 = JSON.Siberia.unforestify(JSON.Siberia.unstringify(serialized));
deepGraphEqual(root, clone2); // true
</code></pre>
<h3>comparison</h3>
will add section later.
<h3>note</h3>
I'm currently refactoring the package. Central ideas and algorithms are staying the same, but the new version will be easier to use, the top level API will be different. I will very soon archive siberia and present the refactored version, which I'll call objectgraph. Stay tuned, it will happen this month (August 2020)
ah, and ultra short version for the comparison. For a &quot;pointer&quot;, I need as much space as an integer takes, since my &quot;pointers to already seen nodes&quot; (as a matter of fact, to all nodes, already seen or not) are just integers. In Mr. Crockford's version, amount needed to store a &quot;pointer&quot; is bounded only by the size of the object graph. That makes the worst case complexity of Mr. Crockford's version extremely horrible. Mr. Crockford gave us &quot;another Bubblesort&quot;. I'm not kidding you. It's that bad. If you don't believe it, there are tests, you can find them starting from the readme of the package (will transform them to be benchmark.js compliant also this month, Aug 2020)

blocks|key|240942|text|这是一种替代答案，但由于许多人来这里的目的是调试他们的循环对象，而没有一种很好的方法可以在不引入大量代码的情况下做到这一点，所以这里就是这样。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|240943|console.table()是一个没有JSON.stringify()那么出名的特性。只需调用console.table(whatever);，它将以表格格式将变量记录在控制台中，这使得仔细阅读变量的内容变得相当容易和方便。|offset|length|style|CODE|240944|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/API/Console/table^0|0|0|F|K|G|1C|O|0|F|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@$D|R|E|S|F|G]|$D|T|E|U|F|G]|$D|V|E|W|F|G]]|9|@$D|X|E|Y|1|Z]]|A|$]]|$1|H|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

This is kind of an alternate-answer, but since what a lot of people will come here for is debugging their circular objects and there's not really a great way to do that without pulling in a bunch of code, here goes.
One feature that's not as well-known as <code>JSON.stringify()</code> is <a href="https://developer.mozilla.org/en-US/docs/Web/API/Console/table" rel="noreferrer"><code>console.table()</code></a>. Simply call <code>console.table(whatever);</code>, and it will log the variable in the console in tabular format, making it rather quite easy and convenient to peruse the variable's contents.

blocks|key|3119393|text|nodejs模块serialijse提供了一种很好的方法来处理任何类型的包含周期或javascript类实例的JSON对象。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3119394|const+{+serialize,+deserialize+}+=+require("serialijse");


++++var+Mary+=+{+name:+"Mary",+friends:+[]+};
++++var+Bob+=+{+name:+"Bob",+friends:+[]+};

++++Mary.friends.push(Bob);
++++Bob.friends.push(Mary);

++++var+group+=+[+Mary,+Bob];
++++console.log(group);

++++//+testing+serialization+using++JSON.stringify/JSON.parse
++++try+{
++++++++var+jstr+=+JSON.stringify(group);
++++++++var+jo+=+JSON.parse(jstr);
++++++++console.log(jo);

++++}+catch+(err)+{
++++++++console.log("+JSON+has+failed+to+manage+object+with+cyclic+deps");
++++++++console.log("++and+has+generated+the+following+error+message",+err.message);
++++}

++++//+now+testing+serialization+using+serialijse++serialize/deserialize
++++var+str+=+serialize(group);
++++var+so+=+deserialize(str);
++++console.log("+However+Serialijse+knows+to+manage+object+with+cyclic+deps+!");
++++console.log(so);
++++assert(so[0].friends[0]+==+so[1]);+//+Mary's+friend+is+Bob|code-block|syntax|javascript|3119395|此序列化程序支持|3119396|在类型化数组的instance|3119397|support的对象definition|unordered-list-item|3119398|
|3119399|reconstruction中，映射|3119400|3119401|循环，并设置|3119402|3119403|功能，以便在类型化数组的序列化映射编码(Float32Array等...+)期间过滤要跳过的属性。对于performance.|3119404|3119405|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/erossignon/serialijse^0|8|A|8|A|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@$9|1B|A|1C|B|C]]|D|@$9|1D|A|1E|1|1F]]|E|$]]|$1|F|3|G|5|H|7|1G|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1H|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|1I|8|@]|D|@]|E|$]]|$1|O|3|P|5|Q|7|1J|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|1K|8|@]|D|@]|E|$]]|$1|T|3|U|5|Q|7|1L|8|@]|D|@]|E|$]]|$1|V|3|S|5|6|7|1M|8|@]|D|@]|E|$]]|$1|W|3|X|5|Q|7|1N|8|@]|D|@]|E|$]]|$1|Y|3|S|5|6|7|1O|8|@]|D|@]|E|$]]|$1|Z|3|10|5|Q|7|1P|8|@]|D|@]|E|$]]|$1|11|3|-4|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|12|3|-4|5|6|7|1R|8|@]|D|@]|E|$]]]|13|$14|$5|15|16|17|E|$18|19]]]]

the nodejs module <a href="https://github.com/erossignon/serialijse" rel="nofollow noreferrer"><code>serialijse</code></a> provides a nice way to deal with any type of JSON objects containing cycles or javascript class instances.
<pre><code>const { serialize, deserialize } = require(&quot;serialijse&quot;);


 var Mary = { name: &quot;Mary&quot;, friends: [] };
 var Bob = { name: &quot;Bob&quot;, friends: [] };

 Mary.friends.push(Bob);
 Bob.friends.push(Mary);

 var group = [ Mary, Bob];
 console.log(group);

 // testing serialization using JSON.stringify/JSON.parse
 try {
 var jstr = JSON.stringify(group);
 var jo = JSON.parse(jstr);
 console.log(jo);

 } catch (err) {
 console.log(&quot; JSON has failed to manage object with cyclic deps&quot;);
 console.log(&quot; and has generated the following error message&quot;, err.message);
 }

 // now testing serialization using serialijse serialize/deserialize
 var str = serialize(group);
 var so = deserialize(str);
 console.log(&quot; However Serialijse knows to manage object with cyclic deps !&quot;);
 console.log(so);
 assert(so[0].friends[0] == so[1]); // Mary's friend is Bob

</code></pre>
this serializer supports
<ul>
<li>cycle in the object definition</li>
<li>reconstruction of class's instance</li>
<li>support for Typed Array, Map, and Set</li>
<li>ability to filter properties to skip during the serialization process.</li>
<li>binary encoding of Typed Array (Float32Array etc ... ) for performance.</li>
</ul>

I have an object (parse tree) that contains child nodes which are references to other nodes. 

I'd like to serialize this object, using <code>JSON.stringify()</code>, but I get 

<blockquote>
 TypeError: cyclic object value
</blockquote>

because of the constructs I mentioned. 

How could I work around this? It does not matter to me whether these references to other nodes are represented or not in the serialized object.

On the other hand, removing these properties from the object when they are being created seems tedious and I wouldn't want to make changes to the parser (narcissus).

Serializing object that contains cyclic object value

数据结构

GitHub

JSON

我有一个对象(parse tree)，它包含引用其他节点的子节点。我想使用JSON.stringify()来序列化这个对象，但是我得到了 TypeError:循环对象值因为我提到的构造。我该如何解决这个问题呢？这些对其他节点的引用是否在序列化对象中表示对我来说并不重要。另一方面，在创建这些属性时将它们从对象中删除似乎很...

问序列化包含循环对象值的对象
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问序列化包含循环对象值的对象EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问序列化包含循环对象值的对象
EN