объект, который вы получаете от

ОО стиль. Обязательно прокрутите вверх и оставьте отзыв на код Дэна. Это мило и быстро и работает как шарм для меня.

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

В Node.js вы можете использовать

{"a":"foo"}

Использование JSON.stringify с пользовательским заменителем. Например:

// Demo: Circular reference
var o = {};
o.o = o;

// Note: cache should not be re-used by repeated calls to JSON.stringify.
var cache = [];
JSON.stringify(o, function(key, value) {
    if (typeof value === 'object' && value !== null) {
        if (cache.indexOf(value) !== -1) {
            // Duplicate reference found
            try {
                // If this value does not reference a parent it can be deduped
                return JSON.parse(JSON.stringify(value));
            } catch (error) {
                // discard key if value cannot be deduped
                return;
            }
        }
        // Store value in our collection
        cache.push(value);
    }
    return value;
});
cache = null; // Enable garbage collection

util.inspect (object)

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

Но концепция стоит: использовать собственный заменитель и отслеживать анализируемый объект ценности.

. Он автоматически заменяет круглые ссылки на «[Круговой]». Несмотря на то, что он встроен (установка не требуется)


, вы должны импортировать его Чтобы использовать его, просто позвоните . Также имейте в виду, что вы можете передать объект параметров для проверки (см. ссылку выше)

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

правильное решение со страницы MDN

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

Теперь я будьте осторожны с разоблачением

Найденные значения должны храниться на каждом элементе ) и там нет необходимости пытаться

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

в цепочке, ведущей к циклической ссылке. в наборе , а не в массиве (вызывается replacer все повторяющиеся значения , а не только круглые. Но, по крайней мере, это не имеет экспоненциальной сложности. JSON.stringify каждый элемент Вы также можете сделать

Как и в принятом ответе, это решение удаляет https://github.com/WebReflection/circular-json Мне очень понравилось решение Trindaz — более подробное, однако в нем есть некоторые ошибки. Я установил их для тех, кто любит это тоже.

Что если вместо одного элемента вы хотите удалить много элементов?

npm i --save circular-json

или оно вернется, если ни один из них не доступен.

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

Вы также можете сделать

const CircularJSON = require('circular-json');

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

Если это требование нарушено, сортировка будет вести себя неопределенно.

Мне очень понравилось решение 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);
};

Обратите внимание, что есть также 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)));

. Я сделал форк для решения этой проблемы (см. Мой cycle.js форк ). Это должно работать нормально:

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

Обратите внимание, что в моем форке JSON.decycle(variable) работает как в оригинале и будет выдавать исключение, когда элемент variable Итак, теперь вы можете сделать это: { *}, что означает, что они оцениваются как ложные в выражениях типа

(конструктор функции JSON.decycle(variable, true) вы принимаете тот факт, что результат не будет обратимым (ретроцикл не будет заново создавать узлы DOM). Элементы DOM должны быть в некоторой степени идентифицируемыми. Например, если значение div имеет идентификатор, тогда он будет заменен строкой "div#id-of-the-element" Глядя на вывод

Самый разумный ответ:

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

при работе в PhantomJS. Например, мы используем PhantomJS QUnit для запуска наших тестов и в нашем json-stringify- safe from @ isaacs— используется в 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));

Это дает: Обратите внимание, что, как и в случае с ванильной функцией JSON.stringify, как упоминалось в @Rob W, вы также можете настроить режим очистки, передав функцию «replacer» в качестве второго аргумента

{
  a: 'foo',
  b: '[Circular]'
}

. Если вам нужен простой пример того, как это сделать, я просто написал собственный заменитель, который преобразует ошибки, регулярные выражения и функции в удобочитаемые строки stringify() Для будущих гуглеров, которые ищут решение этой проблемы, когда вы https://gist.github.com/4653128 говорится, что Глядя на вывод

Решение сводится к тому, чтобы сохранить ссылку на ранее напечатанные объекты в массиве и проверить ее в функции заменителя перед возвратом значения. Это более ограничительно, чем исключение циклических ссылок, поскольку исключает возможность повторной печати объекта дважды, одним из побочных эффектов которого является избегание циклических ссылок. не . Это будет нативное для браузера решение, которое имеет гораздо лучшую производительность, чем использовать Используйте метод JSON.stringify с заменителем. Прочитайте эту документацию для получения дополнительной информации. Глядя на вывод

Найдите способ заполнить массив замен циклическими ссылками. Вы можете использовать метод typeof, чтобы определить, имеет ли свойство тип «объект» (ссылка) и точную проверку на равенство (===) для проверки циклической ссылки.

Пример оболочки:

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

оценивается как: http://msdn.microsoft.com/en-us/library/cc836459 % 28v = vs.94 % 29.aspx { *} P / S: Когда я проверяю Image

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

var replacement = {"b":undefined};

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

с помощью функции:

var a={b:"b"};
a.a=a;
JSON.stringify(preventCircularJson(a));

smart-циркуляр

"{"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, который я ‘ Мы создали под названием Замена циклических ссылок или просто повторяющихся структур внутри объекта путем, ведущим к его первому вхождению (не только the string , выберите их, добавив Этап не совсем необходимо! Вся работа, параллельные вызовы плюс последовательная обработка в правильном порядке, может быть выполнена с помощью функции Глядя на вывод

[циркуляр]

  • Второй аргумент библиотеки JSON.stringify () циркуляр-json на github Как перевернуть строку в JavaScript?

  • Было бы невозможно написать этот код совершенно точно, если бы выражение функции передалось

  • разрешенных персонализированных замен, что удобно для упрощения или игнорирования менее важных частей объекта ;

  • Это вернет # 7bde84

Некоторые полезные функции, которые я нашел полезными: Так что, если вы рискуете добавить число и дату, конвертируйте дату в позволяет вам указать массив имен ключей, которые должны быть сохранены для каждого объекта, с которым он сталкивается в ваших данных. Это может не работать для всех вариантов использования, но является гораздо более простым решением.

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. Определение в этом ответе было изменено так, что оно did хорошо обсудил все это. Имейте в виду, что некоторые из них проще, чем другие, интегрировать на стороне сервера.


Я нашел Поддерживает многоплатформенное использование, но я только до сих пор тестировал его с помощью node.js. , и это хорошо сработало для моей проблемы.

API такой же, так что все, что вам нужно сделать, это включить и использовать его в качестве замены JSON.

  • У него есть свой собственный метод синтаксического анализа, так что вы можете преобразовывать «циклические» сериализованные данные обратно к объекту.
  • Я решаю эту проблему следующим образом:
  • приводит к

TypeError: значение циклического объекта

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

Вот мое решение. Как сказал Энди Э., отвечая на вопрос

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

, другое решение для решения этой проблемы с объектами такого типа — использование этой библиотеки это просто, и вы можете в несколько простых шагов решить эту проблему.

Основываясь на других ответах, я получаю следующий код: он очень хорошо работает с циклическими ссылками, объектами с пользовательской конструкцией ctors.

Тогда вы можете напечатать так:

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

Из данного объекта, который нужно сериализовать,

Использование довольно простое. :

Кэшируйте все объекты, с которыми вы сталкиваетесь при обходе объекта, и присваивайте каждому из них уникальный хэш-идентификатор (также работает автоматически увеличивающееся число)

Github Link

  • DecycledJSON
  • Когда круговая ссылка найдена, пометьте это поле в новом объекте как круговую и сохраните хэш-идентификатор исходного объекта в качестве атрибута.

Пример использования 1: Пример использования 2: Я знаю, что этот вопрос старый и у него много хороших ответов, но я публикую этот ответ из-за его нового вкуса

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;

(es5)

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

Хотя на этот вопрос уже дан достаточный ответ, вы также можете явно удалить соответствующее свойство перед строкой, используя

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

оператор удаления , это избавит от необходимости создавать или поддерживать сложную логику для удаления циклических ссылок.

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

Попробуйте:

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

Хотя на этот вопрос был дан достаточный ответ, вы также можете явное удаление рассматриваемого свойства перед строкой с помощью оператора delete.

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

delete

, что избавит от необходимости создавать или поддерживать сложную логику для удаления циклических ссылок.