就这样吧

npm i --save circular-json

然后在js文件中

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

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

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

2020年更新

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

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

If

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

结果是

TypeError：循环对象值

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

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

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

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中没有抛出循环引用错误。这个答案中的定义被修改了，所以它确实抛出了一个错误。

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

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