JSON.stringify, evitar TypeError: Conversión de estructura circular a JSON

En el nodo.js, puedes usar util.inspect (object). Reemplaza automáticamente los enlaces circulares con " [Circular]".

Aunque esté integrado (no se requiere instalación) , debe importarlo

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

También tenga en cuenta que puede pasar el objeto de opciones para inspeccionar (ver enlace anterior)

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

Por favor, leer y dar felicitaciones a los comentaristas a continuación...

Solo hazlo

npm i --save circular-json

Luego en su archivo js

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

También podrías hacer

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

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

NOTA: No tengo nada que ver con este paquete. Pero lo uso para esto.

Me gustó mucho la solución de Trindaz, más detallada, sin embargo, tenía algunos errores. También las arreglé para quien le guste.

Además, he añadido un límite de longitud en mis objetos de caché.

Si el objeto que estoy imprimiendo es realmente grande - quiero decir infinitamente grande - quiero limitar mi algoritmo.

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

Tenga en cuenta que también hay un método JSON.decycle implementado por Douglas Crockford. Ver su ciclo.js. Esto le permite stringify casi cualquier estructura estándar:

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

También puede recrear el objeto original con el método retrocycle. Por lo tanto, no tiene que eliminar ciclos de los objetos para stringificarlos.

Sin embargo, esto no funcionará para Nodos DOM (que son la causa típica de ciclos en casos de uso de la vida real). Por ejemplo, esto lanzará:

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

He hice un tenedor para resolver ese problema (ver mi ciclo .js fork ). Esto debería funcionar bien:

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

Tenga en cuenta que en mi bifurcación JSON.decycle(variable) funciona como en el original y lanzará una excepción cuando el variable contiene nodos/elementos DOM.

Cuando se utiliza JSON.decycle(variable, true) se acepta el hecho de que el resultado no será reversible (retrocycle no volverá a crear nodos DOM). Sin embargo, los elementos DOM deben ser identificables hasta cierto punto. Por ejemplo, si un elemento div tiene un id, se reemplazará con una cadena "div#id-of-the-element".

Recomiendo revisar json-stringify-safe de @isaacs-- se usa en NPM.

Por cierto - si no estás usando Node.js, solo puede copiar y pegar las líneas 4-27 de la parte relevante del código fuente.

Para instalar:

$ npm install json-stringify-safe --save

Para usar:

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

Esto produce:

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

Tenga en cuenta que, al igual que con el JSON vainilla.stringify función como @ Rob W mencionado, también puede personalizar el comportamiento de desinfección pasando en una función" replacer " como segundo argumento a stringify(). Si necesitas un ejemplo simple de cómo hacer esto, acabo de escribir un sustituto personalizado que coacciona errores, expresiones regulares y funciones en cadenas legibles por humanos aquí.

La respuesta de@RobW es correcta, ¡pero esto es más performante ! Porque usa un 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, discard key
        return;
      }
      // Store value in our set
      cache.add(value);
    }
    return value;
  });
};

Para futuros googlers que busquen una solución a este problema cuando no conozca las claves de todas las referencias circulares, podría usar un wrapper alrededor del JSON.stringify función para descartar referencias circulares. Vea un script de ejemplo en https://gist.github.com/4653128 .

La solución esencialmente se reduce a mantener una referencia a objetos previamente impresos en un array, y verificarlo en una función replacer antes de devolver un valor. Es más constrictivo que solo descartar referencias circulares, porque también descarta imprimir un objeto dos veces, uno de los efectos secundarios de los cuales es evitar referencias circulares.

Ejemplo de envoltura:

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

Utilice el JSON.stringify método con un sustituto. Lea esta documentación para obtener más información. 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));

Encuentre una manera de llenar la matriz de reemplazo con referencias cíclicas. Puede usar el método typeof para encontrar si una propiedad es de tipo 'object' (reference ) y una verificación de igualdad exacta ( = = = ) para verificar la referencia circular.

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

Evalúa a:

"{"b":"b","a":"CIRCULAR_REFERENCE_REMOVED"}"

Con la función:

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

Sé que esta es una pregunta antigua, pero me gustaría sugerir un paquete NPM que he creado llamado smart-circular, que funciona de manera diferente a las otras formas propuestas. Es especialmente útil si estás usando objetos grandes y profundos.

Algunas características son:

• Reemplazar referencias circulares o simplemente estructuras repetidas dentro del objeto por la ruta que conduce a su primera aparición (no solo la cadena [circular]);

• Mirando para las circularidades en una búsqueda de amplitud, el paquete garantiza que este camino sea lo más pequeño posible, lo cual es importante cuando se trata de objetos muy grandes y profundos, donde los caminos pueden ser molestamente largos y difíciles de seguir (el reemplazo personalizado en JSON.stringify hace un DFS);

• Permite reemplazos personalizados, útiles para simplificar o ignorar partes menos importantes del objeto;

• Finalmente, las rutas se escriben exactamente de la manera necesaria para acceder a la campo referenciado, que puede ayudarle a depurar.

Resuelvo este problema así:

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

El segundo argumento para JSON.stringify () también le permite especificar una matriz de nombres de clave que deben conservarse de cada objeto que encuentre dentro de sus datos. Esto puede no funcionar para todos los casos de uso, pero es una solución mucho más simple.

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

Nota: Extrañamente, la definición de objeto de OP no arroja un error de referencia circular en el última Chrome o Firefox. La definición en esta respuesta fue modificada para que hiciera lanzar un error.

Otra solución para resolver este problema con este tipo de objetos es usar esta biblioteca

Https://github.com/ericmuyser/stringy

Es simple y puede resolver esto en unos pocos pasos simples.

Encontré la biblioteca circular-json en github y funcionó bien para mi problema.

Algunas buenas características que encontré útiles:

• Admite el uso multiplataforma, pero solo lo probé con node.js hasta ahora.
• La API es la misma, por lo que todo lo que necesita hacer es incluirla y usarla como reemplazo de JSON.
• Tiene su propio método de análisis para que pueda convertir los datos serializados 'circulares' de nuevo en objeto.

Basado en las otras respuestas termino con el siguiente código. Funciona bastante bien con referencias circulares, objetos con constructores personalizados.

Del objeto dado a ser serializado,

• Almacena en caché todo el objeto que encuentres mientras lo atraviesas y asigna a cada uno de ellos un hashID único (también funciona un número de incremento automático)
• Una vez que se encuentra una referencia circular, marque ese campo en el nuevo objeto como circular y almacene el hashID del objeto original como un atributo.

Enlace Github - DecycledJSON

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;

Ejemplo de Uso 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));

Ejemplo de Uso 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));

Sé que esta pregunta es antigua y tiene muchas respuestas excelentes, pero publico esta respuesta debido a su nuevo sabor (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);
  });
}

Prueba esto:

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

Si

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

Resulta en un

TypeError: valor cíclico del objeto

Entonces es posible que desee imprimir de esta manera:

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