要更新重写JSON工作方式的答案（可能不推荐，但非常简单），不要使用循环JSON（已弃用）。相反，使用后续的，扁平的：

https://www.npmjs.com/package/flatted

借用了上面@user1541685的旧答案，但替换为新答案：

npm i—保存展平

然后在js文件中

const CircularJSON = require('flatted');
const json = CircularJSON.stringify(obj);

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

我建议从@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（）来自定义净化行为。如果您发现自己需要一个简单的示例来说明如何做到这一点，我只是在这里编写了一个自定义替换器，它将错误、正则表达式和函数强制转换为人类可读的字符串。

这里有一个解决方案：

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

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

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

@RobW的答案是正确的，但这更有表现力！因为它使用了hashmap/set：

const customStringify = function (v) {
  const cache = new Set();
  return JSON.stringify(v, function (key, value) {
    if (typeof value === 'object' && value !== null) {
      if (cache.has(value)) {
        // Circular reference found
        try {
          // If this value does not reference a parent it can be deduped
         return JSON.parse(JSON.stringify(value));
        }
        catch (err) {
          // discard key if value cannot be deduped
         return;
        }
      }
      // Store value in our set
      cache.add(value);
    }
    return value;
  });
};