ejemplo - Stringify(convertir a JSON) un objeto JavaScript con referencia circular

recorrer json javascript

Question

Tengo una definición de objeto JavaScript que contiene una referencia circular: tiene una propiedad que hace referencia al objeto principal.

También tiene funciones que no quiero que pasen al servidor. ¿Cómo serializaría y deserializaría estos objetos?

He leído que el mejor método para hacer esto es usar el stringify de Douglas Crockford. Sin embargo, recibo el siguiente error en Chrome:

TypeError: Converting circular structure to JSON

El código:

function finger(xid, xparent){
    this.id = xid;
    this.xparent;
    //other attributes
}

function arm(xid, xparent){
    this.id = xid;
    this.parent = xparent;
    this.fingers = [];

    //other attributes

    this.moveArm = function() {
        //moveArm function details - not included in this testcase
        alert("moveArm Executed");
    }
}

 function person(xid, xparent, xname){
    this.id = xid;
    this.parent = xparent;
    this.name = xname
    this.arms = []

    this.createArms = function () {
        this.arms[this.arms.length] = new arm(this.id, this);
    }
}

function group(xid, xparent){
    this.id = xid;
    this.parent = xparent;
    this.people = [];
    that = this;

    this.createPerson = function () {
        this.people[this.people.length] = new person(this.people.length, this, "someName");
        //other commands
    }

    this.saveGroup = function () {
        alert(JSON.stringify(that.people));
    }
}

Este es un caso de prueba que he creado para esta pregunta. Hay errores dentro de este código, pero esencialmente tengo objetos dentro de los objetos y una referencia que se pasa a cada objeto para mostrar cuál es el objeto principal cuando se crea el objeto. Cada objeto también contiene funciones, que no quiero que se vuelvan cadenas. Solo quiero las propiedades como Person.Name .

¿Cómo serializo antes de enviar al servidor y deserializarlo suponiendo que se pasa el mismo JSON?

Answer 1

Encontré dos módulos adecuados para manejar referencias circulares en JSON.

1. CircularJSON https://github.com/WebReflection/circular-json cuyo resultado se puede utilizar como entrada para .parse (). También funciona en Browsers & Node.js. También vea: http://webreflection.blogspot.com.au/2013/03/solving-cycles-recursions-and-circulars.html
2. Isaacs json-stringify-safe https://github.com/isaacs/json-stringify-safe que quizás sea más legible pero no se puede usar para .parse y solo está disponible para Node.js

Cualquiera de estos debe satisfacer sus necesidades.

Answer 2

Parece que dojo puede representar referencias circulares en JSON en la forma: {"id":"1","me":{"$ref":"1"}}

Aquí hay un ejemplo:

http://jsfiddle.net/dumeG/

require(["dojox/json/ref"], function(){
    var me = {
        name:"Kris",
        father:{name:"Bill"},
        mother:{name:"Karen"}
    };
    me.father.wife = me.mother;
    var jsonMe = dojox.json.ref.toJson(me); // serialize me
    alert(jsonMe);
});​

Produce:

{
   "name":"Kris",
   "father":{
     "name":"Bill",
     "wife":{
          "name":"Karen"
      }
   },
   "mother":{
     "$ref":"#father.wife"
   }
}

Nota: También puede dojox.json.ref.fromJson estos objetos de referencia circular utilizando el método dojox.json.ref.fromJson .

Otros recursos:

¿Cómo serializar el nodo DOM a JSON incluso si hay referencias circulares?

JSON.stringify no puede representar referencias circulares

Answer 3

Sucedió en este hilo porque necesitaba registrar objetos complejos en una página, ya que la eliminación remota no era posible en mi situación particular. Se encuentra el propio cycle.js de Douglas Crockford (inceptor de JSON), que anota las referencias circulares como cadenas de modo que puedan reconectarse después del análisis. La copia profunda eliminada del ciclo es segura para pasar a través de JSON.stringify. ¡Disfrutar!

https://github.com/douglascrockford/JSON-js

cycle.js: este archivo contiene dos funciones, JSON.decycle y JSON.retrocycle, que permiten codificar estructuras cíclicas y dags en JSON, y luego recuperarlos. Esta es una capacidad que no es proporcionada por ES5. JSONPath se utiliza para representar los enlaces.

Answer 4

Usé lo siguiente para eliminar las referencias circulares:

JS.dropClasses = function(o) {

    for (var p in o) {
        if (o[p] instanceof jQuery || o[p] instanceof HTMLElement) {
            o[p] = null;
        }    
        else if (typeof o[p] == ''object'' )
            JS.dropClasses(o[p]);
    }
};

JSON.stringify(JS.dropClasses(e));

Answer 5

El error de estructura circular ocurre cuando tiene una propiedad del objeto que es el objeto mismo directamente ( a -> a ) o indirectamente ( a -> b -> a ).

Para evitar el mensaje de error, indique a JSON.stringify qué hacer cuando encuentre una referencia circular. Por ejemplo, si tiene una persona apuntando a otra persona ("padre"), que puede (o no) señalar a la persona original, haga lo siguiente:

JSON.stringify( that.person, function( key, value) {
  if( key == ''parent'') { return value.id;}
  else {return value;}
})

El segundo parámetro para stringify es una función de filtro . Aquí simplemente convierte el objeto referido a su ID, pero puede hacer lo que quiera para romper la referencia circular.

Puedes probar el código anterior con lo siguiente:

function Person( params) {
  this.id = params[''id''];
  this.name = params[''name'']; 
  this.father = null;
  this.fingers = [];
  // etc.
}

var me = new Person({ id: 1, name: ''Luke''});
var him = new Person( { id:2, name: ''Darth Vader''});
me.father = him; 
JSON.stringify(me); // so far so good

him.father = me; // time travel assumed :-)
JSON.stringify(me); // "TypeError: Converting circular structure to JSON"
// But this should do the job:
JSON.stringify(me, function( key, value) {
  if(key == ''father'') { 
    return value.id;
  } else {
    return value;
  };
});

Por cierto, elegiría un nombre de atributo diferente para " parent ", ya que es una palabra reservada en muchos idiomas (y en DOM). Esto tiende a causar confusión en el camino ...