这里有一个解决方案：

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

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

注意，还有一个由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”。

我为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": {}
    }
  }
}

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工作方式的答案（可能不推荐，但非常简单），不要使用循环JSON（已弃用）。相反，使用后续的，扁平的：

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

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

npm i—保存展平

然后在js文件中

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