@RobW的答案是正确的，但这更有表现力！因为它使用了hashmap/set：

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

要更新重写JSON工作方式的答案（可能不推荐，但非常简单），不要使用循环JSON（已弃用）。相反，使用后续的，扁平的：

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

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

npm i—保存展平

然后在js文件中

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

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

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

我这样解决这个问题：

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

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}