我有一个大对象要转换成JSON并发送。然而，它具有圆形结构。我想丢弃任何存在的循环引用，并发送任何可以字符串化的引用。我该怎么做？
谢谢
var obj = {
a: "foo",
b: obj
}
我想将对象字符串化为：
{"a":"foo"}
当前回答
我想知道为什么还没有人从MDN页面发布正确的解决方案。。。
const circular Reference=｛otherData:123｝；circular Reference.imy=circular参考；常量getCircularReplacer=（）=>{const seed=new WeakSet（）；return（键，值）=>{if（typeof value==“object”&&value！==null）{if（seed.has（value））{回来}见add（值）；}返回值；};};const stringified=JSON.stringify（circularReference，getCircularReplacer（））；console.log（字符串化）；
Seen值应该存储在集合中，而不是数组中（每个元素都会调用replacer）。
与公认的答案一样，此解决方案删除了所有重复值，而不仅仅是循环值。但至少它没有指数级的复杂性。
其他回答
我知道这个问题很老，有很多很好的答案，但我发布这个答案是因为它有新的味道（es5+）
Object.defineProperties（JSON{refStringify：{值：函数（obj）{let objMap=new Map（）；let stringified=JSON.stringify（obj，函数（键、值）{//仅适用于对象if（值类型==“对象”）{//如果具有值，则返回对它的引用if（objMap.has（value））return objMap.get（value）；objMap.set（值，`ref${objMap.size+1｝`）；}返回值；});返回字符串；}},参考解析：{value：函数（str）{let parsed=JSON.parse（str）；let objMap=_createObjectMap（已解析）；objMap.forEach（（value，key）=>_replaceKeyWithObject（value，key））；返回解析；}},});//***************************示例设a={b： 32中，c：{获取a（）{返回a；},获取c（）{返回a.c；}}};let stringified=JSON.refStringify（a）；let parsed=JSON.refParse（字符串化，2）；console.log（已解析，JSON.refStringify（已解析））；//***************************/示例//***************************助手函数_createObjectMap（obj）{let objMap=new Map（）；JSON.stringify（obj，（key，value）=>{if（值类型==“对象”）{if（objMap.has（value））return objMap.get（value）；objMap.set（值，`ref${objMap.size+1｝`）；}返回值；});返回objMap；}函数_replaceKeyWithObject（key，obj，replaceWithObject=obj）{Object.keys（obj）.forEach（k=>{设val=obj[k]；if（val==键）return（obj[k]=replaceWithObject）；if（typeof val=='object'&&val！=replaceWithObject）_replaceKeyWithObject（key，val，replaceWithObject）；});}
使用带有自定义替换符的JSON.stringify。例如：
// Demo: Circular reference
var circ = {};
circ.circ = circ;
// Note: cache should not be re-used by repeated calls to JSON.stringify.
var cache = [];
JSON.stringify(circ, (key, value) => {
if (typeof value === 'object' && value !== null) {
// Duplicate reference found, discard key
if (cache.includes(value)) return;
// Store value in our collection
cache.push(value);
}
return value;
});
cache = null; // Enable garbage collection
本例中的替换符并非100%正确（取决于您对“重复”的定义）。在以下情况下，将丢弃一个值：
var a = {b:1}
var o = {};
o.one = a;
o.two = a;
// one and two point to the same object, but two is discarded:
JSON.stringify(o, ...);
但概念是：使用自定义替换器，并跟踪解析的对象值。
作为es6中编写的实用函数：
// safely handles circular references
JSON.safeStringify = (obj, indent = 2) => {
let cache = [];
const retVal = JSON.stringify(
obj,
(key, value) =>
typeof value === "object" && value !== null
? cache.includes(value)
? undefined // Duplicate reference found, discard key
: cache.push(value) && value // Store value in our collection
: value,
indent
);
cache = null;
return retVal;
};
// Example:
console.log('options', JSON.safeStringify(options))
使用带有替换符的JSON.stringify方法。有关详细信息，请阅读本文档。http://msdn.microsoft.com/en-us/library/cc836459%28v=vs.94%29.aspx
var obj = {
a: "foo",
b: obj
}
var replacement = {"b":undefined};
alert(JSON.stringify(obj,replacement));
找出用循环引用填充替换数组的方法。您可以使用typeof方法来查找属性的类型是否为“object”（引用），并使用精确的等式检查（==）来验证循环引用。
根据其他答案，我最终得到以下代码。它可以很好地处理循环引用、带有自定义构造函数的对象。
从要序列化的给定对象，
缓存遍历对象时遇到的所有对象，并为每个对象分配一个唯一的hashID（自动递增的数字也有效）找到循环引用后，将新对象中的字段标记为循环，并将原始对象的hashID存储为属性。
Github链接-DecycledJSON
DJSHelper = {};
DJSHelper.Cache = [];
DJSHelper.currentHashID = 0;
DJSHelper.ReviveCache = [];
// DOES NOT SERIALIZE FUNCTION
function DJSNode(name, object, isRoot){
this.name = name;
// [ATTRIBUTES] contains the primitive fields of the Node
this.attributes = {};
// [CHILDREN] contains the Object/Typed fields of the Node
// All [CHILDREN] must be of type [DJSNode]
this.children = []; //Array of DJSNodes only
// If [IS-ROOT] is true reset the Cache and currentHashId
// before encoding
isRoot = typeof isRoot === 'undefined'? true:isRoot;
this.isRoot = isRoot;
if(isRoot){
DJSHelper.Cache = [];
DJSHelper.currentHashID = 0;
// CACHE THE ROOT
object.hashID = DJSHelper.currentHashID++;
DJSHelper.Cache.push(object);
}
for(var a in object){
if(object.hasOwnProperty(a)){
var val = object[a];
if (typeof val === 'object') {
// IF OBJECT OR NULL REF.
/***************************************************************************/
// DO NOT REMOVE THE [FALSE] AS THAT WOULD RESET THE [DJSHELPER.CACHE]
// AND THE RESULT WOULD BE STACK OVERFLOW
/***************************************************************************/
if(val !== null) {
if (DJSHelper.Cache.indexOf(val) === -1) {
// VAL NOT IN CACHE
// ADD THE VAL TO CACHE FIRST -> BEFORE DOING RECURSION
val.hashID = DJSHelper.currentHashID++;
//console.log("Assigned", val.hashID, "to", a);
DJSHelper.Cache.push(val);
if (!(val instanceof Array)) {
// VAL NOT AN [ARRAY]
try {
this.children.push(new DJSNode(a, val, false));
} catch (err) {
console.log(err.message, a);
throw err;
}
} else {
// VAL IS AN [ARRAY]
var node = new DJSNode(a, {
array: true,
hashID: val.hashID // HashID of array
}, false);
val.forEach(function (elem, index) {
node.children.push(new DJSNode("elem", {val: elem}, false));
});
this.children.push(node);
}
} else {
// VAL IN CACHE
// ADD A CYCLIC NODE WITH HASH-ID
this.children.push(new DJSNode(a, {
cyclic: true,
hashID: val.hashID
}, false));
}
}else{
// PUT NULL AS AN ATTRIBUTE
this.attributes[a] = 'null';
}
} else if (typeof val !== 'function') {
// MUST BE A PRIMITIVE
// ADD IT AS AN ATTRIBUTE
this.attributes[a] = val;
}
}
}
if(isRoot){
DJSHelper.Cache = null;
}
this.constructorName = object.constructor.name;
}
DJSNode.Revive = function (xmlNode, isRoot) {
// Default value of [isRoot] is True
isRoot = typeof isRoot === 'undefined'?true: isRoot;
var root;
if(isRoot){
DJSHelper.ReviveCache = []; //Garbage Collect
}
if(window[xmlNode.constructorName].toString().indexOf('[native code]') > -1 ) {
// yep, native in the browser
if(xmlNode.constructorName == 'Object'){
root = {};
}else{
return null;
}
}else {
eval('root = new ' + xmlNode.constructorName + "()");
}
//CACHE ROOT INTO REVIVE-CACHE
DJSHelper.ReviveCache[xmlNode.attributes.hashID] = root;
for(var k in xmlNode.attributes){
// PRIMITIVE OR NULL REF FIELDS
if(xmlNode.attributes.hasOwnProperty(k)) {
var a = xmlNode.attributes[k];
if(a == 'null'){
root[k] = null;
}else {
root[k] = a;
}
}
}
xmlNode.children.forEach(function (value) {
// Each children is an [DJSNode]
// [Array]s are stored as [DJSNode] with an positive Array attribute
// So is value
if(value.attributes.array){
// ITS AN [ARRAY]
root[value.name] = [];
value.children.forEach(function (elem) {
root[value.name].push(elem.attributes.val);
});
//console.log("Caching", value.attributes.hashID);
DJSHelper.ReviveCache[value.attributes.hashID] = root[value.name];
}else if(!value.attributes.cyclic){
// ITS AN [OBJECT]
root[value.name] = DJSNode.Revive(value, false);
//console.log("Caching", value.attributes.hashID);
DJSHelper.ReviveCache[value.attributes.hashID] = root[value.name];
}
});
// [SEPARATE ITERATION] TO MAKE SURE ALL POSSIBLE
// [CYCLIC] REFERENCES ARE CACHED PROPERLY
xmlNode.children.forEach(function (value) {
// Each children is an [DJSNode]
// [Array]s are stored as [DJSNode] with an positive Array attribute
// So is value
if(value.attributes.cyclic){
// ITS AND [CYCLIC] REFERENCE
root[value.name] = DJSHelper.ReviveCache[value.attributes.hashID];
}
});
if(isRoot){
DJSHelper.ReviveCache = null; //Garbage Collect
}
return root;
};
DecycledJSON = {};
DecycledJSON.stringify = function (obj) {
return JSON.stringify(new DJSNode("root", obj));
};
DecycledJSON.parse = function (json, replacerObject) {
// use the replacerObject to get the null values
return DJSNode.Revive(JSON.parse(json));
};
DJS = DecycledJSON;
示例用法1：
var obj = {
id:201,
box: {
owner: null,
key: 'storm'
},
lines:[
'item1',
23
]
};
console.log(obj); // ORIGINAL
// SERIALIZE AND THEN PARSE
var jsonObj = DJS.stringify(obj);
console.log(DJS.parse(jsonObj));
示例用法2：
// PERSON OBJECT
function Person() {
this.name = null;
this.child = null;
this.dad = null;
this.mom = null;
}
var Dad = new Person();
Dad.name = 'John';
var Mom = new Person();
Mom.name = 'Sarah';
var Child = new Person();
Child.name = 'Kiddo';
Dad.child = Mom.child = Child;
Child.dad = Dad;
Child.mom = Mom;
console.log(Child); // ORIGINAL
// SERIALIZE AND THEN PARSE
var jsonChild = DJS.stringify(Child);
console.log(DJS.parse(jsonChild));
我知道这是一个老问题，但我想建议一个我创建的NPM包，叫做智能循环，它的工作方式与其他建议的方式不同。如果您使用的是大而深的对象，它特别有用。
一些功能包括：
将循环引用或对象内部简单重复的结构替换为导致其首次出现的路径（而不仅仅是字符串〔circular〕）；通过在广度优先搜索中查找循环，该包确保了该路径尽可能小，这在处理非常大和深度的对象时非常重要，因为这些对象的路径可能非常长且难以遵循（JSON.stringify中的自定义替换是DFS）；允许个性化替换，方便简化或忽略对象的不重要部分；最后，路径完全以访问引用字段所需的方式编写，这可以帮助您进行调试。
