У мене є визначення об’єкта JavaScript, яке містить циклічне посилання: воно має властивість, що посилається на батьківський об’єкт.

Він також має функції, які я не хочу передавати на сервер. Як мені серіалізувати та десеріалізувати ці об’єкти?

Я читав, що найкращим методом для цього є використання stringify Дугласа Крокфорда. Однак у Chrome з’являється така помилка:

TypeError: Перетворення кругової структури в JSON

Код:

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

Це тест, який я створив для цього питання. У цьому коді є помилки, але по суті у мене є об'єкти всередині об'єктів і посилання, передане кожному об'єкту, щоб показати, що таке батьківський об'єкт при створенні об'єкта. Кожен об'єкт також містить функції, які я не хочу розшифровувати. Я просто хочу такі властивості, як Person.Name.

Як мені серіалізувати перед відправкою на сервер і десеріалізувати його, припускаючи, що той самий JSON передається назад?

Помилка кругової структури виникає, коли у вас є властивість об’єкта, яка є самим об’єктом безпосередньо ( a -> a) або опосередковано ( a -> b -> a).

Щоб уникнути повідомлення про помилку, повідомте JSON.stringify, що робити, коли воно зустрічає кругове посилання. Наприклад, якщо у вас є людина, яка вказує на іншу особу ("батька"), яка може (або може не вказувати) на оригінальну особу, зробіть наступне:

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

Другим параметром to stringifyє функція фільтра . Тут він просто перетворює посиланий об'єкт на його ідентифікатор, але ви можете робити все, що завгодно, щоб зламати кругове посилання.

Ви можете протестувати наведений вище код наступним чином:

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

До речі, я б вибрав іншу назву атрибута, ніж " parent", оскільки це зарезервоване слово у багатьох мовах (і в DOM). Це, як правило, викликає плутанину ...

Здається, доджо може представляти кругові посилання в JSON у формі:{"id":"1","me":{"$ref":"1"}}

Ось приклад:

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

Виробляє:

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

Примітка: Ви також можете десериалізувати ці циклічні об'єкти, на які посилаються, використовуючи dojox.json.ref.fromJsonметод.

Інші ресурси:

Як серіалізувати вузол DOM до JSON, навіть якщо є кругові посилання?

JSON.stringify не може представляти кругові посилання

Я знайшов два відповідні модулі для обробки кругових посилань у JSON.

1. CircularJSON https://github.com/WebReflection/circular-json , висновок якого може бути використаний як вхід для .parse (). Він також працює в браузерах і Node.js. Також див.: 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, який може бути більш читабельним, але не може бути використаний для .parse і доступний лише для Node.js

Будь-яка з них повинна відповідати вашим потребам.

Це сталося з цим потоком, тому що мені потрібно було реєструвати складні об’єкти на сторінці, оскільки віддалена налагодження неможлива у моїй конкретній ситуації. Знайдено власний цикл.js Дугласа Крокфорда (автор JSON), який анотує кругові посилання як рядки, щоб їх можна було повторно підключити після синтаксичного аналізу. Розблоковану глибоку копію безпечно передати через JSON.stringify. Насолоджуйтесь!

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

cycle.js: Цей файл містить дві функції, JSON.decycle та JSON.retrocycle, які дають можливість кодувати циклічні структури та даги в JSON, а потім відновити їх. Це можливість, яка не передбачена ES5. JSONPath використовується для представлення посилань.

Ні-lib

Використовуйте замінювач нижче, щоб створити json із посиланнями на рядки (подібний json-шлях ) для дублювання / циклічних об'єктів посилання

let s = JSON.stringify(obj, refReplacer());

function refReplacer() {
  let m = new Map(), v= new Map(), init = null;

  return function(field, value) {
    let p= m.get(this) + (Array.isArray(this) ? `[${field}]` : '.' + field); 
    let isComplex= value===Object(value)
    
    if (isComplex) m.set(value, p);  
    
    let pp = v.get(value)||'';
    let path = p.replace(/undefined\.\.?/,'');
    let val = pp ? `#REF:${pp[0]=='[' ? '$':'$.'}${pp}` : value;
    
    !init ? (init=value) : (val===init ? val="#REF:$" : 0);
    if(!pp && isComplex) v.set(value, path);
   
    return val;
  }
}




// ---------------
// TEST
// ---------------

// gen obj with duplicate references
let a = { a1: 1, a2: 2 };
let b = { b1: 3, b2: "4" };
let obj = { o1: { o2:  a  }, b, a }; // duplicate reference
a.a3 = [1,2,b];                      // circular reference
b.b3 = a;                            // circular reference


let s = JSON.stringify(obj, refReplacer(), 4);

console.log(s);

І наступна функція аналізатора для регенерації об'єкта з такого "ref-json"

function parseRefJSON(json) {
  let objToPath = new Map();
  let pathToObj = new Map();
  let o = JSON.parse(json);
  
  let traverse = (parent, field) => {
    let obj = parent;
    let path = '#REF:$';

    if (field !== undefined) {
      obj = parent[field];
      path = objToPath.get(parent) + (Array.isArray(parent) ? `[${field}]` : `${field?'.'+field:''}`);
    }

    objToPath.set(obj, path);
    pathToObj.set(path, obj);
    
    let ref = pathToObj.get(obj);
    if (ref) parent[field] = ref;

    for (let f in obj) if (obj === Object(obj)) traverse(obj, f);
  }
  
  traverse(o);
  return o;
}



// ------------
// TEST
// ------------

let s = `{
    "o1": {
        "o2": {
            "a1": 1,
            "a2": 2,
            "a3": [
                1,
                2,
                {
                    "b1": 3,
                    "b2": "4",
                    "b3": "#REF:$.o1.o2"
                }
            ]
        }
    },
    "b": "#REF:$.o1.o2.a3[2]",
    "a": "#REF:$.o1.o2"
}`;

console.log('Open Chrome console to see nested fields:');
let obj = parseRefJSON(s);

console.log(obj);

Для усунення кругових посилань я використав наступне:

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