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

试试看：

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

当你不知道所有循环引用的键时，对于未来搜索这个问题解决方案的谷歌用户，你可以使用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);
}

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

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

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

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

一些功能包括：

将循环引用或对象内部简单重复的结构替换为导致其首次出现的路径（而不仅仅是字符串〔circular〕）；通过在广度优先搜索中查找循环，该包确保了该路径尽可能小，这在处理非常大和深度的对象时非常重要，因为这些对象的路径可能非常长且难以遵循（JSON.stringify中的自定义替换是DFS）；允许个性化替换，方便简化或忽略对象的不重要部分；最后，路径完全以访问引用字段所需的方式编写，这可以帮助您进行调试。

本线程中的大多数答案都是专门针对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));