我想知道为什么还没有人从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）。

与公认的答案一样，此解决方案删除了所有重复值，而不仅仅是循环值。但至少它没有指数级的复杂性。

我建议从@isaacs中检查json字符串安全性——它在NPM中使用。

顺便说一下，如果你没有使用Node.js，你可以从源代码的相关部分复制并粘贴第4-27行。

要安装：

$ npm install json-stringify-safe --save

要使用：

// Require the thing
var stringify = require('json-stringify-safe');

// Take some nasty circular object
var theBigNasty = {
  a: "foo",
  b: theBigNasty
};

// Then clean it up a little bit
var sanitized = JSON.parse(stringify(theBigNasty));

这产生了：

{
  a: 'foo',
  b: '[Circular]'
}

注意，就像@Rob W提到的普通JSON.stringify函数一样，您也可以通过将“replacer”函数作为第二个参数传递给stringify（）来自定义净化行为。如果您发现自己需要一个简单的示例来说明如何做到这一点，我只是在这里编写了一个自定义替换器，它将错误、正则表达式和函数强制转换为人类可读的字符串。

使用带有自定义替换符的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))

这里有一个解决方案：

仅删除循环（而不是所有重复的对象引用，到目前为止这里发布的大多数解决方案也是如此），不是不必要的冗长，速度快，不需要任何库依赖关系。

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]'}}"

我真的很喜欢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);
};

我知道这个问题很老，有很多很好的答案，但我发布这个答案是因为它有新的味道（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）；});}