ฉันมีวัตถุขนาดใหญ่ที่ฉันต้องการแปลงเป็น JSON และส่ง อย่างไรก็ตามมีโครงสร้างเป็นวงกลม ฉันต้องการโยนการอ้างอิงแบบวงกลมใด ๆ ที่มีอยู่และส่งสิ่งที่สามารถทำให้เป็นสตริงได้ ฉันจะทำอย่างไร

ขอบคุณ

var obj = {
  a: "foo",
  b: obj
}

ฉันต้องการ string obj เป็น:

{"a":"foo"}

ใช้JSON.stringifyร่วมกับ replacer แบบกำหนดเอง ตัวอย่างเช่น:

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

ใน Node.js คุณสามารถใช้util.inspect (วัตถุ) มันจะแทนที่ลิงก์แบบวงกลมด้วย "[เวียน]" โดยอัตโนมัติ

แม้ว่าจะมีอยู่แล้วภายใน(ไม่จำเป็นต้องติดตั้ง)คุณต้องนำเข้า

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

โปรดทราบด้วยว่าคุณสามารถส่งวัตถุตัวเลือกเพื่อตรวจสอบ(ดูลิงก์ด้านบน)

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

กรุณาอ่านและให้ความชื่นชมกับผู้แสดงความคิดเห็นด้านล่าง ...

ฉันสงสัยว่าทำไมไม่มีใครโพสต์โซลูชันที่เหมาะสมจากหน้า MDNเลย ...

const getCircularReplacer = () => {
  const seen = new WeakSet();
  return (key, value) => {
    if (typeof value === "object" && value !== null) {
      if (seen.has(value)) {
        return;
      }
      seen.add(value);
    }
    return value;
  };
};

JSON.stringify(circularReference, getCircularReplacer());

ค่าที่เห็นควรเก็บไว้ในเซตไม่ใช่ในอาเรย์ (ตัวเรียกซ้ำจะถูกเรียกใช้ในทุกองค์ประกอบ ) และไม่จำเป็นต้องลองJSON.stringify แต่ละองค์ประกอบในห่วงโซ่ที่นำไปสู่การอ้างอิงแบบวงกลม

เช่นเดียวกับในคำตอบที่ได้รับการยอมรับโซลูชันนี้จะลบค่าการทำซ้ำทั้งหมดไม่ใช่เฉพาะค่าเวียน แต่อย่างน้อยก็ไม่ได้มีความซับซ้อนที่อธิบาย

แค่ทำ

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

@ คำตอบของ 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.decycleวิธีการใช้งานโดยดักลาสคร็อคฟอร์ด ดูเขา cycle.js สิ่งนี้ช่วยให้คุณสามารถสร้างโครงสร้างมาตรฐานเกือบทั้งหมด:

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

นอกจากนี้คุณยังสามารถสร้างวัตถุเดิมด้วยretrocycleวิธีการ ดังนั้นคุณไม่ต้องลบรอบจากวัตถุเพื่อทำให้เป็นก้อน

อย่างไรก็ตามสิ่งนี้จะไม่ทำงานสำหรับโหนด DOM (ซึ่งเป็นสาเหตุทั่วไปของวงจรในกรณีใช้งานจริงในชีวิต) เช่นนี้จะโยน:

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

ฉันได้แยกทางเพื่อแก้ไขปัญหานั้น (ดูfork cycle.jsของฉัน) สิ่งนี้จะทำงานได้ดี:

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

โปรดทราบว่าในส้อมของฉันJSON.decycle(variable)ทำงานเหมือนในต้นฉบับและจะโยนข้อยกเว้นเมื่อvariableมีโหนด / องค์ประกอบ DOM

เมื่อคุณใช้JSON.decycle(variable, true)คุณยอมรับความจริงที่ว่าผลลัพธ์จะไม่สามารถย้อนกลับได้ (retrocycle จะไม่สร้างโหนด DOM ใหม่) องค์ประกอบ DOM ควรระบุได้ในระดับหนึ่งแม้ว่า ตัวอย่างเช่นถ้าองค์ประกอบมีรหัสแล้วมันจะถูกแทนที่ด้วยสตริงdiv"div#id-of-the-element"

ฉันขอแนะนำให้เช็คเอาท์ json-stringify-safeจาก @ isaacs - มันถูกใช้ใน NPM

BTW- หากคุณไม่ได้ใช้ 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]'
}

โปรดทราบว่าเช่นเดียวกับวานิลลาฟังก์ชั่นเป็น JSON.stringify @ Rob W กล่าวนอกจากนี้คุณยังสามารถปรับแต่งพฤติกรรมการฆ่าเชื้อโดยผ่านใน "ทดแทน" stringify()ฟังก์ชั่นเป็นอาร์กิวเมนต์ที่สองที่จะ หากคุณพบว่าตัวเองต้องเป็นตัวอย่างง่ายๆของวิธีการทำนี้ผมเพิ่งเขียนทดแทนที่กำหนดเองซึ่ง coerces ข้อผิดพลาด regexps และฟังก์ชั่นเป็นสตริงมนุษย์สามารถอ่านได้ที่นี่

สำหรับชาว Google ในอนาคตหาวิธีแก้ปัญหาเพื่อแก้ไขปัญหานี้เมื่อคุณไม่ได้รู้ว่ากุญแจของการอ้างอิงแบบวงกลมทั้งหมดที่คุณสามารถใช้ห่อหุ้มรอบฟังก์ชัน JSON.stringify เพื่อออกกฎการอ้างอิงแบบวงกลม ดูสคริปต์ตัวอย่างได้ที่https://gist.github.com/4653128 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);
}

ใช้วิธี JSON.stringify ด้วยตัวจำลอง อ่านเอกสารนี้สำหรับข้อมูลเพิ่มเติม http://msdn.microsoft.com/en-us/library/cc836459%28v=vs.94%29.aspx

var obj = {
  a: "foo",
  b: obj
}

var replacement = {"b":undefined};

alert(JSON.stringify(obj,replacement));

หาวิธีที่จะเติมอาเรย์แทนที่ด้วยการอ้างอิงแบบวนซ้ำ คุณสามารถใช้วิธี typeof เพื่อค้นหาว่าคุณสมบัตินั้นเป็นประเภท 'วัตถุ' (อ้างอิง) และการตรวจสอบความเท่าเทียมกันที่แน่นอน (===) เพื่อตรวจสอบการอ้างอิงแบบวงกลม

ถ้า

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

ผลลัพธ์ใน

TypeError: ค่าของวัตถุที่เป็นวงจร

จากนั้นคุณอาจต้องการพิมพ์ดังนี้:

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

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

ฉันรู้ว่านี่เป็นคำถามเก่า แต่ฉันอยากจะแนะนำแพ็กเกจ NPM ที่ฉันสร้างขึ้นซึ่งเรียกว่าสมาร์ทเวียนซึ่งทำงานแตกต่างจากวิธีอื่น ๆ ที่เสนอ มันมีประโยชน์เป็นพิเศษหากคุณใช้วัตถุขนาดใหญ่และลึกวัตถุที่มีขนาดใหญ่และลึก

คุณสมบัติบางอย่างคือ:

• การแทนที่การอ้างอิงแบบวงกลมหรือโครงสร้างที่ทำซ้ำภายในวัตถุโดยเส้นทางที่นำไปสู่การเกิดขึ้นครั้งแรก (ไม่ใช่แค่สตริง[วงเวียน] );

• ด้วยการมองหาหนังสือเวียนในการค้นหาแบบกว้าง ๆ แพ็คเกจจะทำให้เส้นทางนี้มีขนาดเล็กที่สุดเท่าที่จะเป็นไปได้ซึ่งมีความสำคัญเมื่อต้องจัดการกับวัตถุที่มีขนาดใหญ่และลึกมาก JSON.stringify ทำ DFS);

• ช่วยให้การเปลี่ยนแบบส่วนบุคคลสะดวกในการทำให้ง่ายขึ้นหรือไม่สนใจส่วนที่สำคัญน้อยกว่าของวัตถุ

• ในที่สุดเส้นทางจะถูกเขียนอย่างแม่นยำตามวิธีที่จำเป็นในการเข้าถึงฟิลด์อ้างอิงซึ่งสามารถช่วยคุณในการดีบัก

อาร์กิวเมนต์ที่สองเพื่อ 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 ล่าสุด ความหมายในคำตอบนี้มีการปรับเปลี่ยนเพื่อที่จะได้โยนความผิดพลาด

ในการอัปเดตคำตอบของการเอาชนะวิธีการทำงานของ JSON (อาจไม่แนะนำ แต่ง่ายสุด ๆ ) อย่าใช้circular-json(มันเลิกใช้แล้ว) ให้ใช้ตัวตายตัวแทนแทน

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

ยืมมาจากคำตอบเก่าด้านบนจาก @ user1541685 แต่แทนที่ด้วยคำตอบใหม่:

npm i --save flatted

จากนั้นในไฟล์ js ของคุณ

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

ฉันพบห้องสมุด Circular-json บน GitHubและทำงานได้ดีสำหรับปัญหาของฉัน

คุณสมบัติที่ดีที่ฉันพบมีประโยชน์:

• รองรับการใช้งานหลายแพลตฟอร์ม แต่ฉันทดสอบด้วย node.js เท่านั้น
• API เหมือนกันดังนั้นสิ่งที่คุณต้องทำคือรวมและใช้แทน JSON
• มันมีวิธีการแยกวิเคราะห์เป็นของตัวเองเพื่อให้คุณสามารถแปลงข้อมูล 'วงกลม' ต่อเนื่องเป็นวัตถุ

ฉันแก้ไขปัญหาเช่นนี้:

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

ฉันรู้ว่าคำถามนี้เก่าและมีคำตอบที่ดีมาก แต่ฉันโพสต์คำตอบนี้เพราะมันเป็นรสชาติใหม่(es5 +)

Object.defineProperties(JSON, {
  refStringify: {
    value: function(obj) {

      let objMap = new Map();
      let stringified = JSON.stringify(obj,
        function(key, value) {

          // only for objects
          if (typeof value == 'object') {
            // If has the value then return a reference to it
            if (objMap.has(value))
              return objMap.get(value);

            objMap.set(value, `ref${objMap.size + 1}`);
          }
          return value;
        });
      return stringified;
    }
  },
  refParse: {
    value: function(str) {

      let parsed = JSON.parse(str);
      let objMap = _createObjectMap(parsed);
      objMap.forEach((value, key) => _replaceKeyWithObject(value, key));
      return parsed;
    }
  },
});

// *************************** Example
let a = {
  b: 32,
  c: {
    get a() {
        return a;
      },
      get c() {
        return a.c;
      }
  }
};
let stringified = JSON.refStringify(a);
let parsed = JSON.refParse(stringified, 2);
console.log(parsed, JSON.refStringify(parsed));
// *************************** /Example

// *************************** Helper
function _createObjectMap(obj) {

  let objMap = new Map();
  JSON.stringify(obj, (key, value) => {
    if (typeof value == 'object') {
      if (objMap.has(value))
        return objMap.get(value);
      objMap.set(value, `ref${objMap.size + 1}`);

    }
    return value;
  });
  return objMap;
}

function _replaceKeyWithObject(key, obj, replaceWithObject = obj) {

  Object.keys(obj).forEach(k => {

    let val = obj[k];
    if (val == key)
      return (obj[k] = replaceWithObject);
    if (typeof val == 'object' && val != replaceWithObject)
      _replaceKeyWithObject(key, val, replaceWithObject);
  });
}

แม้ว่าสิ่งนี้จะได้รับคำตอบอย่างเพียงพอ แต่คุณสามารถลบคุณสมบัติที่เป็นปัญหาได้อย่างชัดเจนก่อนที่จะทำการสร้างสตริงด้วยตัวdeleteดำเนินการ

delete obj.b; 
const jsonObject = JSON.stringify(obj);

ลบโอเปอเรเตอร์

สิ่งนี้จะลบความจำเป็นในการสร้างหรือรักษาตรรกะที่ซับซ้อนเพื่อลบการอ้างอิงแบบวงกลม

function myStringify(obj, maxDeepLevel = 2) {
  if (obj === null) {
    return 'null';
  }
  if (obj === undefined) {
    return 'undefined';
  }
  if (maxDeepLevel < 0 || typeof obj !== 'object') {
    return obj.toString();
  }
  return Object
    .entries(obj)
    .map(x => x[0] + ': ' + myStringify(x[1], maxDeepLevel - 1))
    .join('\r\n');
}

โซลูชันอื่นสำหรับการแก้ไขปัญหานี้ด้วยวัตถุประเภทนี้คือการใช้ไลบรารีนี้

https://github.com/ericmuyser/stringy

มันง่ายและคุณสามารถในขั้นตอนง่าย ๆ แก้ปัญหานี้

ตามคำตอบอื่น ๆ ฉันท้ายด้วยรหัสต่อไปนี้ มันใช้งานได้ดีกับการอ้างอิงแบบวงกลมวัตถุที่มีตัวสร้างแบบกำหนดเอง

จากวัตถุที่กำหนดที่จะต่อเนื่องกัน

• แคชวัตถุทั้งหมดที่คุณเจอในขณะที่สำรวจวัตถุและกำหนด hashID ที่ไม่ซ้ำกันแต่ละอัน (หมายเลขที่เพิ่มขึ้นอัตโนมัติยังใช้งานได้)
• เมื่อพบการอ้างอิงแบบวงกลมให้ทำเครื่องหมายฟิลด์นั้นในวัตถุใหม่เป็นแบบวงกลมและเก็บ hashID ของวัตถุดั้งเดิมเป็นแอตทริบิวต์

ลิงค์ Github - นำกลับมาใช้ใหม่ JSON

DJSHelper = {};
DJSHelper.Cache = [];
DJSHelper.currentHashID = 0;
DJSHelper.ReviveCache = [];

// DOES NOT SERIALIZE FUNCTION
function DJSNode(name, object, isRoot){
    this.name = name;
    // [ATTRIBUTES] contains the primitive fields of the Node
    this.attributes = {};

    // [CHILDREN] contains the Object/Typed fields of the Node
    // All [CHILDREN] must be of type [DJSNode]
    this.children = []; //Array of DJSNodes only

    // If [IS-ROOT] is true reset the Cache and currentHashId
    // before encoding
    isRoot = typeof isRoot === 'undefined'? true:isRoot;
    this.isRoot = isRoot;
    if(isRoot){
        DJSHelper.Cache = [];
        DJSHelper.currentHashID = 0;

        // CACHE THE ROOT
        object.hashID = DJSHelper.currentHashID++;
        DJSHelper.Cache.push(object);
    }

    for(var a in object){
        if(object.hasOwnProperty(a)){
            var val = object[a];

            if (typeof val === 'object') {
                // IF OBJECT OR NULL REF.

                /***************************************************************************/
                // DO NOT REMOVE THE [FALSE] AS THAT WOULD RESET THE [DJSHELPER.CACHE]
                // AND THE RESULT WOULD BE STACK OVERFLOW
                /***************************************************************************/
                if(val !== null) {
                    if (DJSHelper.Cache.indexOf(val) === -1) {
                        // VAL NOT IN CACHE
                        // ADD THE VAL TO CACHE FIRST -> BEFORE DOING RECURSION
                        val.hashID = DJSHelper.currentHashID++;
                        //console.log("Assigned", val.hashID, "to", a);
                        DJSHelper.Cache.push(val);

                        if (!(val instanceof Array)) {
                            // VAL NOT AN [ARRAY]
                            try {
                                this.children.push(new DJSNode(a, val, false));
                            } catch (err) {
                                console.log(err.message, a);
                                throw err;
                            }
                        } else {
                            // VAL IS AN [ARRAY]
                            var node = new DJSNode(a, {
                                array: true,
                                hashID: val.hashID // HashID of array
                            }, false);
                            val.forEach(function (elem, index) {
                                node.children.push(new DJSNode("elem", {val: elem}, false));
                            });
                            this.children.push(node);
                        }
                    } else {
                        // VAL IN CACHE
                        // ADD A CYCLIC NODE WITH HASH-ID
                        this.children.push(new DJSNode(a, {
                            cyclic: true,
                            hashID: val.hashID
                        }, false));
                    }
                }else{
                    // PUT NULL AS AN ATTRIBUTE
                    this.attributes[a] = 'null';
                }
            } else if (typeof val !== 'function') {
                // MUST BE A PRIMITIVE
                // ADD IT AS AN ATTRIBUTE
                this.attributes[a] = val;
            }
        }
    }

    if(isRoot){
        DJSHelper.Cache = null;
    }
    this.constructorName = object.constructor.name;
}
DJSNode.Revive = function (xmlNode, isRoot) {
    // Default value of [isRoot] is True
    isRoot = typeof isRoot === 'undefined'?true: isRoot;
    var root;
    if(isRoot){
        DJSHelper.ReviveCache = []; //Garbage Collect
    }
    if(window[xmlNode.constructorName].toString().indexOf('[native code]') > -1 ) {
        // yep, native in the browser
        if(xmlNode.constructorName == 'Object'){
            root = {};
        }else{
            return null;
        }
    }else {
        eval('root = new ' + xmlNode.constructorName + "()");
    }

    //CACHE ROOT INTO REVIVE-CACHE
    DJSHelper.ReviveCache[xmlNode.attributes.hashID] = root;

    for(var k in xmlNode.attributes){
        // PRIMITIVE OR NULL REF FIELDS
        if(xmlNode.attributes.hasOwnProperty(k)) {
            var a = xmlNode.attributes[k];
            if(a == 'null'){
                root[k] = null;
            }else {
                root[k] = a;
            }
        }
    }

    xmlNode.children.forEach(function (value) {
        // Each children is an [DJSNode]
        // [Array]s are stored as [DJSNode] with an positive Array attribute
        // So is value

        if(value.attributes.array){
            // ITS AN [ARRAY]
            root[value.name] = [];
            value.children.forEach(function (elem) {
                root[value.name].push(elem.attributes.val);
            });
            //console.log("Caching", value.attributes.hashID);
            DJSHelper.ReviveCache[value.attributes.hashID] = root[value.name];
        }else if(!value.attributes.cyclic){
            // ITS AN [OBJECT]
            root[value.name] = DJSNode.Revive(value, false);
            //console.log("Caching", value.attributes.hashID);
            DJSHelper.ReviveCache[value.attributes.hashID] = root[value.name];
        }
    });

    // [SEPARATE ITERATION] TO MAKE SURE ALL POSSIBLE
    // [CYCLIC] REFERENCES ARE CACHED PROPERLY
    xmlNode.children.forEach(function (value) {
        // Each children is an [DJSNode]
        // [Array]s are stored as [DJSNode] with an positive Array attribute
        // So is value

        if(value.attributes.cyclic){
            // ITS AND [CYCLIC] REFERENCE
            root[value.name] = DJSHelper.ReviveCache[value.attributes.hashID];
        }
    });

    if(isRoot){
        DJSHelper.ReviveCache = null; //Garbage Collect
    }
    return root;
};

DecycledJSON = {};
DecycledJSON.stringify = function (obj) {
    return JSON.stringify(new DJSNode("root", obj));
};
DecycledJSON.parse = function (json, replacerObject) {
    // use the replacerObject to get the null values
    return DJSNode.Revive(JSON.parse(json));
};
DJS = DecycledJSON;

ตัวอย่างการใช้ 1:

var obj = {
    id:201,
    box: {
        owner: null,
        key: 'storm'
    },
    lines:[
        'item1',
        23
    ]
};

console.log(obj); // ORIGINAL

// SERIALIZE AND THEN PARSE
var jsonObj = DJS.stringify(obj);
console.log(DJS.parse(jsonObj));

ตัวอย่างการใช้ 2:

// PERSON OBJECT

function Person() {
    this.name = null;
    this.child = null;
    this.dad = null;
    this.mom = null;
}
var Dad = new Person();
Dad.name = 'John';
var Mom = new Person();
Mom.name = 'Sarah';
var Child = new Person();
Child.name = 'Kiddo';

Dad.child = Mom.child = Child;
Child.dad = Dad;
Child.mom = Mom;

console.log(Child); // ORIGINAL

// SERIALIZE AND THEN PARSE
var jsonChild = DJS.stringify(Child);
console.log(DJS.parse(jsonChild));

ลองสิ่งนี้:

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

ในโซลูชันของฉันถ้าคุณเจอรอบมันไม่เพียง แต่พูดว่า "รอบ" (หรืออะไรก็ได้) มันพูดอะไรบางอย่างเช่น foo: ดูวัตถุ # 42 ด้านบนและเพื่อดูว่าจุดใดที่ foo ชี้ไปที่คุณสามารถเลื่อนขึ้นและค้นหา สำหรับออบเจ็กต์ # 42 (แต่ละออบเจ็กต์เมื่อเริ่มต้นจะพูดว่า object # xxx ด้วยจำนวนเต็ม xxx บางตัว)

ตัวอย่างข้อมูล:

(function(){
	"use strict";
	var ignore = [Boolean, Date, Number, RegExp, String];
	function primitive(item){
		if (typeof item === 'object'){
			if (item === null) { return true; }
			for (var i=0; i<ignore.length; i++){
				if (item instanceof ignore[i]) { return true; }
			}
			return false;
		} else {
			return true;
		}
	}
	function infant(value){
		return Array.isArray(value) ? [] : {};
	}
	JSON.decycleIntoForest = function decycleIntoForest(object, replacer) {
		if (typeof replacer !== 'function'){
			replacer = function(x){ return x; }
		}
		object = replacer(object);
		if (primitive(object)) return object;
		var objects = [object];
		var forest  = [infant(object)];
		var bucket  = new WeakMap(); // bucket = inverse of objects 
		bucket.set(object, 0);       // i.e., map object to index in array
		function addToBucket(obj){
			var result = objects.length;
			objects.push(obj);
			bucket.set(obj, result);
			return result;
		}
		function isInBucket(obj){
			return bucket.has(obj);
			// objects[bucket.get(obj)] === obj, iff true is returned
		}
		function processNode(source, target){
			Object.keys(source).forEach(function(key){
				var value = replacer(source[key]);
				if (primitive(value)){
					target[key] = {value: value};
				} else {
					var ptr;
					if (isInBucket(value)){
						ptr = bucket.get(value);
					} else {
						ptr = addToBucket(value);
						var newTree = infant(value);
						forest.push(newTree);
						processNode(value, newTree);
					}
					target[key] = {pointer: ptr};
				}
			});
		}
		processNode(object, forest[0]);
		return forest;
	};
})();
the = document.getElementById('the');
function consoleLog(toBeLogged){
  the.textContent = the.textContent + '\n' + toBeLogged;
}
function show(root){
	var cycleFree = JSON.decycleIntoForest(root);
	var shown = cycleFree.map(function(tree, idx){ return false; });
	var indentIncrement = 4;
	function showItem(nodeSlot, indent, label){
	  leadingSpaces = ' '.repeat(indent);
      leadingSpacesPlus = ' '.repeat(indent + indentIncrement);
	  if (shown[nodeSlot]){
	  consoleLog(leadingSpaces + label + ' ... see above (object #' + nodeSlot + ')');
        } else {
		  consoleLog(leadingSpaces + label + ' object#' + nodeSlot);
		  var tree = cycleFree[nodeSlot];
		  shown[nodeSlot] = true;
		  Object.keys(tree).forEach(function(key){
			var entry = tree[key];
			if ('value' in entry){
			  consoleLog(leadingSpacesPlus + key + ": " + entry.value);
                } else {
					if ('pointer' in entry){
						showItem(entry.pointer, indent+indentIncrement, key);
                    }
                }
			});
        }
    }
	showItem(0, 0, 'root');
}
cities4d = {
	Europe:{
		north:[
			{name:"Stockholm", population:1000000, temp:6},
			{name:"Helsinki", population:650000, temp:7.6}
		],
		south:[
			{name:"Madrid", population:3200000, temp:15},
			{name:"Rome", population:4300000, temp:15}
		]
	},
	America:{
		north:[
			{name:"San Francisco", population:900000, temp:14},
			{name:"Quebec", population:530000, temp:4}
		],
		south:[
			{name:"Rio de Janeiro", population:7500000, temp:24},
			{name:"Santiago", population:6300000, temp:14}
		]
	},
	Asia:{
		north:[
			{name:"Moscow", population:13200000, temp:6}
		]
	}
};
cities4d.Europe.north[0].alsoStartsWithS = cities4d.America.north[0];
cities4d.Europe.north[0].smaller = cities4d.Europe.north[1];
cities4d.Europe.south[1].sameLanguage = cities4d.America.south[1];
cities4d.Asia.ptrToRoot = cities4d;
show(cities4d)

<pre id="the"></pre>