JSON.stringify () химерність масиву з Prototype.js

Я намагаюся зрозуміти, що пішло не так з моєю серіалізацією json, маю поточну версію мого додатка зі старою і виявляю деякі дивовижні відмінності в роботі JSON.stringify () (Використовуючи бібліотеку JSON з json.org ).

У старій версії мого додатка:

 JSON.stringify({"a":[1,2]})

дає мені це;

"{\"a\":[1,2]}"

у новій версії,

 JSON.stringify({"a":[1,2]})

дає мені це;

"{\"a\":\"[1, 2]\"}"

будь-яка ідея, що могло змінитися, щоб та сама бібліотека поставила лапки навколо дужок масиву в новій версії?

Оскільки останнім часом JSON.stringify постачається з деякими браузерами, я б запропонував використовувати його замість прототипу toJSON. Потім ви перевірите наявність window.JSON && window.JSON.stringify і включите лише бібліотеку json.org в іншому випадку (через document.createElement('script')…). Щоб усунути несумісність, використовуйте:

if(window.Prototype) {
    delete Object.prototype.toJSON;
    delete Array.prototype.toJSON;
    delete Hash.prototype.toJSON;
    delete String.prototype.toJSON;
}

Функція JSON.stringify (), визначена в ECMAScript 5 і вище (Сторінка 201 - Об'єкт JSON, псевдокод Сторінка 205) , використовує функцію JSON (), коли доступна для об'єктів.

Оскільки Prototype.js (або інша бібліотека, яку ви використовуєте) визначає функцію Array.prototype.toJSON (), масиви спочатку перетворюються у рядки за допомогою Array.prototype.toJSON (), а потім рядок, цитований JSON.stringify (), отже, неправильні зайві лапки навколо масивів.

Тому рішення є прямим і тривіальним (це спрощена версія відповіді Рафаеля Швайкерта):

delete Array.prototype.toJSON

Це, звичайно, побічно впливає на бібліотеки, які покладаються на властивість функції toJSON () для масивів. Але я вважаю це незначною незручністю, враховуючи несумісність із ECMAScript 5.

Слід зазначити, що об'єкт JSON, визначений у ECMAScript 5, ефективно реалізований у сучасних браузерах, і тому найкращим рішенням є відповідність стандарту та модифікація існуючих бібліотек.

Можливим рішенням, яке не вплине на інші залежності Прототипу, є:

var _json_stringify = JSON.stringify;
JSON.stringify = function(value) {
    var _array_tojson = Array.prototype.toJSON;
    delete Array.prototype.toJSON;
    var r=_json_stringify(value);
    Array.prototype.toJSON = _array_tojson;
    return r;
};

Це піклується про несумісність масиву toJSON з JSON.stringify, а також зберігає функціональність toJSON, оскільки інші бібліотеки прототипів можуть залежати від цього.

Редагуйте, щоб зробити трохи точнішим:

Біт ключового коду проблеми знаходиться в бібліотеці JSON з JSON.org (та інших реалізаціях об'єкта JSON ECMAScript 5):

if (value && typeof value === 'object' &&
  typeof value.toJSON === 'function') {
  value = value.toJSON(key);
}

Проблема полягає в тому, що бібліотека Prototype розширює Array, включаючи метод toJSON, який об'єкт JSON буде викликати в коді вище. Коли об'єкт JSON потрапляє у значення масиву, він викликає JSON у масиві, який визначено у прототипі, і цей метод повертає строкову версію масиву. Отже, лапки навколо дужок масиву.

Якщо видалити toJSON з об'єкта Array, бібліотека JSON повинна працювати належним чином. Або просто скористайтеся бібліотекою JSON.

Я думаю, кращим рішенням було б включити це відразу після завантаження прототипу

JSON = JSON || {};

JSON.stringify = function(value) { return value.toJSON(); };

JSON.parse = JSON.parse || function(jsonsring) { return jsonsring.evalJSON(true); };

Це робить функцію прототипу доступною як стандартні JSON.stringify () та JSON.parse (), але зберігає власну JSON.parse (), якщо вона доступна, тому це робить речі більш сумісними зі старими браузерами.

Я не так вільно володію прототипом, але я бачив це в його документах :

Object.toJSON({"a":[1,2]})

Але я не впевнений, чи матиме це таку саму проблему, як у поточного кодування.

Також є довший підручник про використання JSON з прототипом.

Це код, який я використовував для тієї ж проблеми:

function stringify(object){
      var Prototype = window.Prototype
      if (Prototype && Prototype.Version < '1.7' &&
          Array.prototype.toJSON && Object.toJSON){
              return Object.toJSON(object)
      }
      return JSON.stringify(object)
}

Ви перевіряєте, чи існує Прототип, а потім перевіряєте версію. Якщо стара версія використовує Object.toJSON (якщо визначено), у всіх інших випадках повертається до JSON.stringify ()

Ось як я з цим маю справу.

var methodCallString =  Object.toJSON? Object.toJSON(options.jsonMethodCall) :  JSON.stringify(options.jsonMethodCall);

Моє толерантне рішення перевіряє, чи Array.prototype.toJSON шкідливий для JSON stringify, і зберігає його, коли це можливо, щоб дозволити навколишньому коду працювати належним чином:

var dummy = { data: [{hello: 'world'}] }, test = {};

if(Array.prototype.toJSON) {
    try {
        test = JSON.parse(JSON.stringify(dummy));
        if(!test || dummy.data !== test.data) {
            delete Array.prototype.toJSON;
        }
    } catch(e) {
        // there only hope
    }
}

Як люди зазначали, це пов’язано з Prototype.js - зокрема версіями до 1.7. У мене була подібна ситуація, але я мав мати код, який би працював незалежно від того, був там Prototype.js чи ні; це означає, що я не можу просто видалити Array.prototype.toJSON, оскільки я не впевнений, що на нього покладається. Для такої ситуації це найкраще рішення, яке я придумав:

function safeToJSON(item){ 
    if ([1,2,3] === JSON.parse(JSON.stringify([1,2,3]))){
        return JSON.stringify(item); //sane behavior
    } else { 
        return item.toJSON(); // Prototype.js nonsense
    }
}

Сподіваємось, це комусь допоможе.

Якщо ви не хочете вбивати все, і у вас є код, який би працював у більшості браузерів, ви можете зробити це таким чином:

(function (undefined) { // This is just to limit _json_stringify to this scope and to redefine undefined in case it was
  if (true ||typeof (Prototype) !== 'undefined') {
    // First, ensure we can access the prototype of an object.
    // See http://stackoverflow.com/questions/7662147/how-to-access-object-prototype-in-javascript
    if(typeof (Object.getPrototypeOf) === 'undefined') {
      if(({}).__proto__ === Object.prototype && ([]).__proto__ === Array.prototype) {
        Object.getPrototypeOf = function getPrototypeOf (object) {
          return object.__proto__;
        };
      } else {
        Object.getPrototypeOf = function getPrototypeOf (object) {
          // May break if the constructor has been changed or removed
          return object.constructor ? object.constructor.prototype : undefined;
        }
      }
    }

    var _json_stringify = JSON.stringify; // We save the actual JSON.stringify
    JSON.stringify = function stringify (obj) {
      var obj_prototype = Object.getPrototypeOf(obj),
          old_json = obj_prototype.toJSON, // We save the toJSON of the object
          res = null;
      if (old_json) { // If toJSON exists on the object
        obj_prototype.toJSON = undefined;
      }
      res = _json_stringify.apply(this, arguments);
      if (old_json)
        obj_prototype.toJSON = old_json;
      return res;
    };
  }
}.call(this));

Це здається складним, але це складне лише для обробки більшості випадків використання. Основна ідея полягає в тому, JSON.stringifyщоб видалити toJSONз об'єкта, переданого як аргумент, потім викликати старий JSON.stringifyі, нарешті, відновити його.