在 Node.js 中，可以使用 util.inspect(object(。它会自动将循环链接替换为"[循环]"。

尽管它是内置的(不需要安装(，但您必须导入它

import * as util from 'util' // has no default export
import { inspect } from 'util' // or directly
// or 
var util = require('util')

要使用它，只需调用

console.log(util.inspect(myObject))

另请注意，您可以将选项对象传递给检查(请参阅上面的链接(

inspect(myObject[, options: {showHidden, depth, colors, showProxy, ...moreOptions}])

请阅读并向下面的评论者点赞...

将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))

我想知道为什么还没有人从 MDN 页面发布正确的解决方案......

const circularReference = {otherData: 123};
circularReference.myself = circularReference;
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;
  };
};
const stringified = JSON.stringify(circularReference, getCircularReplacer());
console.log(stringified);

看到的值应该存储在集合中，而不是数组中(替换器在每个元素上被调用(。使用数组会导致二次O((N^2 + N)/2)复杂性而不是线性O(N)！

请注意，就像在接受的答案中一样，此解决方案会删除所有重复值，而不仅仅是循环值。

只是做

npm i --save circular-json

然后在您的 js 文件中

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

https://github.com/WebReflection/circular-json

注意：我与此软件包无关。但我确实用它来做这个。

2020 年更新

请注意，CircularJSON 仅在维护中，扁平化是其继任者。

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

请注意，Douglas Crockford 还实现了JSON.decycle方法。看他的循环.js。这允许您字符串化几乎任何标准结构：

var a = [];
a[0] = a;
a[1] = 123;
console.log(JSON.stringify(JSON.decycle(a)));
// result: '[{"$ref":"$"},123]'.

您还可以使用retrocycle方法重新创建原始对象。因此，您不必从对象中删除循环来串化它们。

但是，这不适用于 DOM 节点(这是现实用例中循环的典型原因(。例如，这将抛出：

var a = [document.body];
console.log(JSON.stringify(JSON.decycle(a)));

我做了一个叉子来解决这个问题(请参阅我的周期.js叉(。这应该可以正常工作：

var a = [document.body];
console.log(JSON.stringify(JSON.decycle(a, true)));

请注意，在我的 fork 中，JSON.decycle(variable)的工作方式与原始版本相同，并且当variable包含 DOM 节点/元素时会抛出异常。

当你使用JSON.decycle(variable, true)你接受结果是不可逆的事实(逆向循环不会重新创建 DOM 节点(。不过，DOM 元素应该在某种程度上是可识别的。例如，如果一个div元素有一个id，那么它将被替换为字符串"div#id-of-the-element"。

@RobW的答案是正确的，但这更高性能！因为它使用哈希映射/集合：

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;
  });
};

我建议从@isaacs中查看json-stringify-safe-它在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]'
}

请注意，就像 W 提到的 vanilla JSON.stringify 函数@Rob一样，您还可以通过将"替换器"函数作为第二个参数传递给 stringify() 来自定义清理行为。 如果你发现自己需要一个简单的例子来说明如何做到这一点，我刚刚写了一个自定义替换器，它在这里将错误、正则表达式和函数强制为人类可读的字符串。

对于未来的谷歌用户，当你不知道所有循环引用的键时，你可以使用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);
}

var a={b:"b"};
a.a=a;
JSON.stringify(preventCircularJson(a));

评估结果为：

"{"b":"b","a":"CIRCULAR_REFERENCE_REMOVED"}"

使用函数：

/**
 * Traverses a javascript object, and deletes all circular values
 * @param source object to remove circular references from
 * @param censoredMessage optional: what to put instead of censored values
 * @param censorTheseItems should be kept null, used in recursion
 * @returns {undefined}
 */
function preventCircularJson(source, censoredMessage, censorTheseItems) {
    //init recursive value if this is the first call
    censorTheseItems = censorTheseItems || [source];
    //default if none is specified
    censoredMessage = censoredMessage || "CIRCULAR_REFERENCE_REMOVED";
    //values that have allready apeared will be placed here:
    var recursiveItems = {};
    //initaite a censored clone to return back
    var ret = {};
    //traverse the object:
    for (var key in source) {
        var value = source[key]
        if (typeof value == "object") {
            //re-examine all complex children again later:
            recursiveItems[key] = value;
        } else {
            //simple values copied as is
            ret[key] = value;
        }
    }
    //create list of values to censor:
    var censorChildItems = [];
    for (var key in recursiveItems) {
        var value = source[key];
        //all complex child objects should not apear again in children:
        censorChildItems.push(value);
    }
    //censor all circular values
    for (var key in recursiveItems) {
        var value = source[key];
        var censored = false;
        censorTheseItems.forEach(function (item) {
            if (item === value) {
                censored = true;
            }
        });
        if (censored) {
            //change circular values to this
            value = censoredMessage;
        } else {
            //recursion:
            value = preventCircularJson(value, censoredMessage, censorChildItems.concat(censorTheseItems));
        }
        ret[key] = value
    }
    return ret;
}

使用 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 方法查找属性是否属于"对象"类型(引用(和精确相等性检查 (=== ( 来验证循环引用。

if

console.log(JSON.stringify(object));

结果为

类型错误：循环对象值

然后你可能想像这样打印：

var output = '';
for (property in object) {
  output += property + ': ' + object[property]+'; ';
}
console.log(output);

我知道这是一个老问题，但我想建议我创建的一个名为智能循环的 NPM 包，它的工作方式与其他提议的方式不同。如果您使用的是大而深的物体，它特别有用。

一些功能是：

• 将循环引用或对象内部的简单重复结构替换为导致其第一次出现的路径(不仅仅是字符串 [循环](;

• 通过在广度优先搜索中查找循环，该包确保此路径尽可能小，这在处理非常大和深的对象时很重要，在这些对象中，路径可能会变得令人讨厌的长且难以遵循(JSON.stringify 中的自定义替换执行 DFS(;

• 允许个性化替换，方便简化或忽略对象中不太重要的部分;

• 最后，路径完全按照访问引用字段所需的方式编写，这可以帮助您进行调试。

JSON.stringify(( 的第二个参数还允许您指定一个键名数组，这些键名应该从数据中遇到的每个对象中保留。这可能不适用于所有用例，但是一个更简单的解决方案。

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify

var obj = {
    a: "foo",
    b: this
}
var json = JSON.stringify(obj, ['a']);
console.log(json);
// {"a":"foo"}

注意：奇怪的是，OP 中的对象定义不会在最新的 Chrome 或 Firefox 中抛出循环引用错误。此答案中的定义已修改，因此确实会引发错误。

我在github上找到了循环json库，它很好地解决了我的问题。

我发现一些有用的好功能：

• 支持多平台使用，但到目前为止.js我只用 node 对其进行了测试。
• API 是相同的，因此您需要做的就是包含并使用它作为 JSON 替代品。
• 它有自己的解析方法，因此您可以将"循环"序列化数据转换回对象。

要更新覆盖 JSON 工作方式的答案(可能不推荐，但超级简单(，请不要使用 circular-json(已弃用(。相反，请使用后继者，扁平化：

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

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

npm i --save flatted

然后在您的 js 文件中

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

此代码对于循环引用将失败：

    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());

此解决方案修复了 user2451227 在接受答案 ( when o = {}; JSON.stringify([o, o], getCircularReplacer()) 上报告的问题。

function newCircularReplacer () {
  const seenValues = []
  return circularReplacer
  function circularReplacer (key, value) {
    if (typeof value === 'object' && value !== null && Object.keys(value).length) {
      const stackSize = seenValues.length
      if (stackSize) {
        for (let n = stackSize - 1; seenValues[n][key] !== value; --n) seenValues.pop() // Clean up expired references
        if (seenValues.includes(value)) return '[Circular]'
      }
      seenValues.push(value)
    }
    return value
  }
}
let o = {a: 1}
o.b = o // Circular reference
console.log(
  JSON.stringify(o, newCircularReplacer()) // {a:1,b:[Circular]} ✅
)
o = {}
const notCircularReference = [o, o]
console.log(
  JSON.stringify(notCircularReference, newCircularReplacer()) // [{},{}] ✅ (NOT circular reference)
)

我像这样解决这个问题：

var util = require('util');
// Our circular object
var obj = {foo: {bar: null}, a:{a:{a:{a:{a:{a:{a:{hi: 'Yo!'}}}}}}}};
obj.foo.bar = obj;
// Generate almost valid JS object definition code (typeof string)
var str = util.inspect(b, {depth: null});
// Fix code to the valid state (in this example it is not required, but my object was huge and complex, and I needed this for my case)
str = str
    .replace(/<Buffer[ 'w'.]+>/ig, '"buffer"')
    .replace(/'[Function]/ig, 'function(){}')
    .replace(/'[Circular]/ig, '"Circular"')
    .replace(/'{ '[Function: (['w]+)]/ig, '{ $1: function $1 () {},')
    .replace(/'[Function: (['w]+)]/ig, 'function $1(){}')
    .replace(/('w+): (['w :]+GMT'+['w '(')]+),/ig, '$1: new Date("$2"),')
    .replace(/('S+): ,/ig, '$1: null,');
// Create function to eval stringifyed code
var foo = new Function('return ' + str + ';');
// And have fun
console.log(JSON.stringify(foo(), null, 4));

试试这个：

var obj = {
    a: "foo",
    b: obj
};
var circular_replacer = (value) => {
    var seen = [];
    if (value != null && typeof value == "object") {
        if (seen.indexOf(value) >= 0) return;
        seen.push(value);
    }
    return value;
};
obj = circular_replacer(obj);

尽管这已经得到了充分的回答，但您也可以在字符串化之前使用 delete 运算符显式删除有问题的属性。

delete obj.b; 
const jsonObject = JSON.stringify(obj);

删除运算符

这将消除构建或维护复杂逻辑以删除循环引用的需要。

function myStringify(obj, maxDeepLevel = 2) {
  if (obj === null) {
    return 'null';
  }
  if (obj === undefined) {
    return 'undefined';
  }
  if (maxDeepLevel < 0 || typeof obj !== 'object') {
    return obj.toString();
  }
  return Object
    .entries(obj)
    .map(x => x[0] + ': ' + myStringify(x[1], maxDeepLevel - 1))
    .join(''r'n');
}

这是一个解决方案：

• 仅删除循环(而不是所有重复的对象引用，到目前为止，此处发布的大多数解决方案也是如此(，
• 不是不必要的冗长，
• 很快，
• 不需要任何库依赖项。

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

解决此问题的另一种解决方案是使用此库

https://github.com/ericmuyser/stringy

它很简单，您可以通过几个简单的步骤解决此问题。

基于其他答案，我最终得到以下代码。它非常适合循环引用，带有自定义构造函数的对象。

从要序列化的给定对象，

• 缓存遍历对象时遇到的所有对象，并为每个对象分配一个唯一的hashID(自动递增的数字也可以(
• 找到循环引用后，将新对象中的该字段标记为循环，并将原始对象的 hashID 存储为属性。

Github Link - 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));

这个问题很旧，有很多很棒的答案，但我发布这个答案是因为它是新的味道 (es5+(

Object.defineProperties(JSON, {
  refStringify: {
    value: function(obj) {
      let objMap = new Map();
      let stringified = JSON.stringify(obj,
        function(key, value) {
          // only for objects
          if (typeof value == 'object') {
            // If has the value then return a reference to it
            if (objMap.has(value))
              return objMap.get(value);
            objMap.set(value, `ref${objMap.size + 1}`);
          }
          return value;
        });
      return stringified;
    }
  },
  refParse: {
    value: function(str) {
      let parsed = JSON.parse(str);
      let objMap = _createObjectMap(parsed);
      objMap.forEach((value, key) => _replaceKeyWithObject(value, key));
      return parsed;
    }
  },
});
// *************************** Example
let a = {
  b: 32,
  c: {
    get a() {
        return a;
      },
      get c() {
        return a.c;
      }
  }
};
let stringified = JSON.refStringify(a);
let parsed = JSON.refParse(stringified, 2);
console.log(parsed, JSON.refStringify(parsed));
// *************************** /Example
// *************************** Helper
function _createObjectMap(obj) {
  let objMap = new Map();
  JSON.stringify(obj, (key, value) => {
    if (typeof value == 'object') {
      if (objMap.has(value))
        return objMap.get(value);
      objMap.set(value, `ref${objMap.size + 1}`);
    }
    return value;
  });
  return objMap;
}
function _replaceKeyWithObject(key, obj, replaceWithObject = obj) {
  Object.keys(obj).forEach(k => {
    let val = obj[k];
    if (val == key)
      return (obj[k] = replaceWithObject);
    if (typeof val == 'object' && val != replaceWithObject)
      _replaceKeyWithObject(key, val, replaceWithObject);
  });
}

你可以试试JSON解析器库：treedoc。 它支持循环引用，并且还使用引用对重复的对象进行重复删除。

yarn add treedoc

import {TD} from 'treedoc'
TD.stringify(obj);

如果你想要更多的定制

import {TD, TDEncodeOption} from 'treedoc'
const opt = new TDEncodeOption();
opt.coderOption.setShowType(true).setShowFunction(true);
opt.jsonOption.setIndentFactor(2);
return TD.stringify(obj, opt);

查看器 http://treedoc.org 可以查看生成的 JSON 文件，该查看器支持通过 JSON 节点引用进行导航。

[无耻的插头]我是这个库的作者

此线程中的大多数答案都专门用于JSON.stringify - 它们没有显示如何实际删除原始对象树中的循环引用。(好吧，之后不会再次调用JSON.parse - 这需要重新分配，并且对性能有更高的影响(

要从源对象树中删除循环引用，可以使用如下函数： https://stackoverflow.com/a/63952549/2441655

然后，这些通用的循环引用删除器函数可用于使对循环引用敏感函数(如JSON.stringify(的后续调用安全：

const objTree = {normalProp: true};
objTree.selfReference = objTree;
RemoveCircularLinks(objTree); // without this line, the JSON.stringify call errors
console.log(JSON.stringify(objTree));

我为我的 LoggingUtilities 类创建了以下方法。以下方法采用源对象和目标对象，并通过给定的 maxLevel 将源分配给目标。

  static assignObjectByLevel(
    sourceObject: any,
    targetObject: any,
    currentLevel: number = 0,
    maxLevel: number = 3,
    showUndefinedValues = false
  ): any {
    if (currentLevel >= maxLevel) {
      return;
    }
    const objQueue = [];
    for (const key in sourceObject) {
      if (sourceObject.hasOwnProperty(key)) {
        const value = sourceObject[key];
        if (typeof value === "object") {
          objQueue.push({ key, value });
        } else {
          targetObject[key] = value;
        }
      } else {
        if (showUndefinedValues) {
          targetObject[key] = "undefined/null";
        }
      }
    }
    while (objQueue.length > 0) {
      const objVal = objQueue.pop();
      currentLevel++;
      targetObject[objVal.key] = {};
      this.assignObjectByLevel(
        objVal.value,
        targetObject[objVal.key],
        currentLevel,
        maxLevel,
        false
      );
    }
  }

使用示例：

   const logObjParam = {
      level1: "value1",
      level2: {
        value2: "value2",
        level3: {
          value3: "value3",
          level4: {
            value4: " value4",
            level5: {
              value5: " value5",
            },
          },
        },
      },
    };
 let logObj = {};
 this.assignObjectByLevel(logObjParam, logObj);

结果：

{
  "level1": "value1",
  "level2": {
    "value2": "value2",
    "level3": {
      "value3": "value3",
      "level4": {}
    }
  }
}

superserial 完全序列化 JavaScript 对象。

https://github.com/denostack/superserial

用法：

const serializer = new Serializer();
const nodes = [{ self: null as any, siblings: [] as any[] }, {
  self: null as any,
  siblings: [] as any[],
}];
nodes[0].self = nodes[0];
nodes[0].siblings = nodes;
nodes[1].self = nodes[1];
nodes[1].siblings = nodes;
const serialized = serializer.serialize(nodes);
console.log(serialized);

输出：

[$1,$2];{"self":$1,"siblings":$0};{"self":$2,"siblings":$0}