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

在Node.js中，您可以使用util.inspect（object）。它会自动将循环链接替换为“[circular]”。

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

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

还要注意，您可以传递options对象以进行检查（请参见上面的链接）

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

请阅读下面的评论并给予表扬。。。

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

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

一些功能包括：

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

注意，还有一个由Douglas Crockford实现的JSON.decycle方法。看看他的cycle.js。这允许您对几乎任何标准结构进行字符串化：

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

您也可以使用逆循环方法重新创建原始对象。因此，您不必从对象中删除循环来将其字符串化。

然而，这对于DOM节点（在现实生活中，这是周期的典型原因）不起作用。例如，这将抛出：

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

我做了一个叉来解决这个问题（参见我的cycle.js叉）。这应该很好：

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

注意，在我的fork中，JSON.decycle（变量）的工作方式与原始一样，当变量包含DOM节点/元素时，将抛出异常。

当您使用JSON.decycle（variable，true）时，您接受这样一个事实，即结果是不可逆的（retrocycle不会重新创建DOM节点）。但DOM元素在某种程度上应该是可识别的。例如，如果一个div元素有一个id，那么它将被替换为字符串“div#id of the element”。

If

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

结果是

TypeError：循环对象值

然后，您可能想要这样打印：

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