我有一个大对象要转换成JSON并发送。然而，它具有圆形结构。我想丢弃任何存在的循环引用，并发送任何可以字符串化的引用。我该怎么做？
谢谢
var obj = {
a: "foo",
b: obj
}
我想将对象字符串化为：
{"a":"foo"}
当前回答
我真的很喜欢Trindaz的解决方案——更详细，但它有一些缺陷。我也为喜欢它的人修过。
此外，我对缓存对象添加了长度限制。
如果我打印的对象真的很大-我的意思是无限大-我想限制我的算法。
JSON.stringifyOnce = function(obj, replacer, indent){
var printedObjects = [];
var printedObjectKeys = [];
function printOnceReplacer(key, value){
if ( printedObjects.length > 2000){ // browsers will not print more than 20K, I don't see the point to allow 2K.. algorithm will not be fast anyway if we have too many objects
return 'object too long';
}
var printedObjIndex = false;
printedObjects.forEach(function(obj, index){
if(obj===value){
printedObjIndex = index;
}
});
if ( key == ''){ //root element
printedObjects.push(obj);
printedObjectKeys.push("root");
return value;
}
else if(printedObjIndex+"" != "false" && typeof(value)=="object"){
if ( printedObjectKeys[printedObjIndex] == "root"){
return "(pointer to root)";
}else{
return "(see " + ((!!value && !!value.constructor) ? value.constructor.name.toLowerCase() : typeof(value)) + " with key " + printedObjectKeys[printedObjIndex] + ")";
}
}else{
var qualifiedKey = key || "(empty key)";
printedObjects.push(value);
printedObjectKeys.push(qualifiedKey);
if(replacer){
return replacer(key, value);
}else{
return value;
}
}
}
return JSON.stringify(obj, printOnceReplacer, indent);
};
其他回答
循环引用时，此代码将失败：
JSON.stringify(circularReference);
// TypeError: cyclic object value
使用以下代码：
const getCircularReplacer = () => {
const seen = new WeakSet();
return (key, value) => {
if (typeof value === "object" && value !== null) {
if (seen.has(value)) {
return;
}
seen.add(value);
}
return value;
};
};
JSON.stringify(circularReference, getCircularReplacer());
使用此类对象解决此问题的另一种解决方案是使用此库
https://github.com/ericmuyser/stringy
它很简单，你可以在几个简单的步骤中解决这个问题。
当你不知道所有循环引用的键时，对于未来搜索这个问题解决方案的谷歌用户，你可以使用JSON.stringify函数的包装器来排除循环引用。参见示例脚本https://gist.github.com/4653128.
解决方案本质上归结为在数组中保留对先前打印对象的引用，并在返回值之前在替换函数中检查该引用。它比仅排除循环引用更具限制性，因为它还排除了两次打印对象的可能性，其副作用之一是避免循环引用。
包装示例：
function stringifyOnce(obj, replacer, indent){
var printedObjects = [];
var printedObjectKeys = [];
function printOnceReplacer(key, value){
var printedObjIndex = false;
printedObjects.forEach(function(obj, index){
if(obj===value){
printedObjIndex = index;
}
});
if(printedObjIndex && typeof(value)=="object"){
return "(see " + value.constructor.name.toLowerCase() + " with key " + printedObjectKeys[printedObjIndex] + ")";
}else{
var qualifiedKey = key || "(empty key)";
printedObjects.push(value);
printedObjectKeys.push(qualifiedKey);
if(replacer){
return replacer(key, value);
}else{
return value;
}
}
}
return JSON.stringify(obj, printOnceReplacer, indent);
}
这里有一个解决方案：
仅删除循环（而不是所有重复的对象引用，到目前为止这里发布的大多数解决方案也是如此），不是不必要的冗长，速度快，不需要任何库依赖关系。
function replaceCycles(obj, replacement = undefined, seen = new WeakSet()) {
if (typeof obj === 'object')
if (seen.has(obj))
return replacement
else {
seen.add(obj)
const newObj = {}
for (const key in obj)
newObj[key] = replaceCycles(obj[key], replacement, seen)
seen.delete(obj)
return newObj
}
else
return obj
}
用法：
const a = {
b: 'v1',
c: {
d: 'v2'
}
}
a.e = a.c
a.c.f = a.c
console.log(JSON.stringify(replaceCycles(a, '[CYCLE]')))
输出：
"{'b':'v1','c':{'d':'v2','f':'[CYCLE]'},'e':{'d':'v2','f':'[CYCLE]'}}"
我想知道为什么还没有人从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）。
与公认的答案一样，此解决方案删除了所有重复值，而不仅仅是循环值。但至少它没有指数级的复杂性。
