Serializzazione di un oggetto che contiene un valore oggetto ciclico

Question

Ho un oggetto (albero di analisi) che contiene nodi figli che sono riferimenti ad altri nodi.

Vorrei serializzare questo oggetto, utilizzando JSON.stringify(), ma ottengo

TypeError: valore oggetto ciclico

a causa dei costrutti che ho citato.

Come potrei aggirare questo problema?Non mi importa se questi riferimenti ad altri nodi sono rappresentati o meno nell'oggetto serializzato.

D'altra parte, rimuovere queste proprietà dall'oggetto quando vengono creati sembra noioso e non vorrei apportare modifiche al parser (narcissus).

Answer 1

Utilizza il secondo parametro di stringify, funzione di sostituzione , per escludere oggetti già serializzati:

var seen = [];

JSON.stringify(obj, function(key, val) {
   if (val != null && typeof val == "object") {
        if (seen.indexOf(val) >= 0) {
            return;
        }
        seen.push(val);
    }
    return val;
});

http://jsfiddle.net/mH6cJ/38/

Come correttamente sottolineato in altri commenti, questo codice rimuove ogni oggetto "visto", non solo quelli "ricorsivi".

Ad esempio, per:

a = {x:1};
obj = [a, a];

il risultato sarà errato. Se la tua struttura è così, potresti utilizzare il decycle o questa (più semplice) che sostituisce semplicemente i riferimenti ricorsivi con valori nulli:

function decycle(obj, stack = []) {
    if (!obj || typeof obj !== 'object')
        return obj;
    
    if (stack.includes(obj))
        return null;

    let s = stack.concat([obj]);

    return Array.isArray(obj)
        ? obj.map(x => decycle(x, s))
        : Object.fromEntries(
            Object.entries(obj)
                .map(([k, v]) => [k, decycle(v, s)]));
}

//

let a = {b: [1, 2, 3]}
a.b.push(a);

console.log(JSON.stringify(decycle(a)))

Answer 2

Ho creato un GitHub Gist che è in grado di rilevare strutture cicliche e anche di de- e codificarle: https://gist.github.com/Hoff97/9842228

Per trasformare basta usare JSONE.stringify / JSONE.parse. Inoltre de- e codifica le funzioni.Se vuoi disabilitarlo, rimuovi le righe 32-48 e 61-85.

var strg = JSONE.stringify(cyclicObject);
var cycObject = JSONE.parse(strg);

Puoi trovare un esempio di violino qui:

http://jsfiddle.net/hoff97/7UYd4/

Answer 3

molto risparmiatore e mostra dove si trovava un oggetto ciclo .

<script>
var jsonify=function(o){
    var seen=[];
    var jso=JSON.stringify(o, function(k,v){
        if (typeof v =='object') {
            if ( !seen.indexOf(v) ) { return '__cycle__'; }
            seen.push(v);
        } return v;
    });
    return jso;
};
var obj={
    g:{
        d:[2,5],
        j:2
    },
    e:10
};
obj.someloopshere = [
    obj.g,
    obj,
    { a: [ obj.e, obj ] }
];
console.log('jsonify=',jsonify(obj));
</script>

produce

jsonify = {"g":{"d":[2,5],"j":2},"e":10,"someloopshere":[{"d":[2,5],"j":2},"__cycle__",{"a":[10,"__cycle__"]}]}

Answer 4

function stringifyObject ( obj ) {
  if ( _.isArray( obj ) || !_.isObject( obj ) ) {
    return obj.toString()
  }
  var seen = [];
  return JSON.stringify(
    obj,
    function( key, val ) {
      if (val != null && typeof val == "object") {
        if ( seen.indexOf( val ) >= 0 )
          return
          seen.push( val )
          }
      return val
    }
  );
}

Mancava una precondizione, altrimenti i valori interi negli oggetti array vengono troncati, ovvero [[08.11.2014 12:30:13, 1095]] 1095 viene ridotto a 095.

Answer 5

Creo anche un progetto github che può serializzare oggetti ciclici e ripristinare la classe se la salvi nell'attributo serializename come una String

var d={}
var a = {b:25,c:6,enfant:d};
d.papa=a;
var b = serializeObjet(a);
assert.equal(  b, "{0:{b:25,c:6,enfant:'tab[1]'},1:{papa:'tab[0]'}}" );
var retCaseDep = parseChaine(b)
assert.equal(  retCaseDep.b, 25 );
assert.equal(  retCaseDep.enfant.papa, retCaseDep );

https://github.com/bormat/serializeStringifyParseCyclicObject

Modifica: Ho trasformato il mio script per NPM https://github.com/bormat/borto_circular_serialize e ho cambiatonomi di funzioni dal francese all'inglese.