Bizzarria dell'array JSON.stringify () con Prototype.js

Sto cercando di capire cosa è andato storto con la mia serializzazione json, ho la versione corrente della mia app con e quella vecchia e sto trovando alcune sorprendenti differenze nel modo in cui funziona JSON.stringify () (utilizzando la libreria JSON da json.org ).

Nella vecchia versione della mia app:

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

mi dà questo;

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

nella nuova versione,

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

mi dà questo;

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

qualche idea su cosa sarebbe potuto cambiare per fare in modo che la stessa libreria mettesse le virgolette attorno alle parentesi dell'array nella nuova versione?

Poiché JSON.stringify è stato fornito con alcuni browser ultimamente, suggerirei di usarlo al posto di toJSON di Prototype. Dovresti quindi controllare window.JSON && window.JSON.stringify e includere solo la libreria json.org altrimenti (tramite document.createElement('script')...). Per risolvere le incompatibilità, utilizzare:

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

La funzione JSON.stringify () definita in ECMAScript 5 e versioni successive (Pagina 201 - Oggetto JSON, pseudo-codice Pagina 205) , utilizza la funzione toJSON () quando disponibile sugli oggetti.

Poiché Prototype.js (o un'altra libreria che stai utilizzando) definisce una funzione Array.prototype.toJSON (), gli array vengono prima convertiti in stringhe utilizzando Array.prototype.toJSON () quindi stringa citata da JSON.stringify (), da cui il virgolette extra errate intorno agli array.

La soluzione è quindi semplice e banale (questa è una versione semplificata della risposta di Raphael Schweikert):

delete Array.prototype.toJSON

Ciò produce ovviamente effetti collaterali sulle librerie che si basano su una proprietà della funzione toJSON () per gli array. Ma trovo questo un piccolo inconveniente considerando l'incompatibilità con ECMAScript 5.

Va notato che l'oggetto JSON definito in ECMAScript 5 è implementato in modo efficiente nei browser moderni e quindi la soluzione migliore è conformarsi allo standard e modificare le librerie esistenti.

Una possibile soluzione che non influenzerà altre dipendenze del prototipo sarebbe:

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

Questo si prende cura dell'incompatibilità di Array toJSON con JSON.stringify e mantiene anche la funzionalità toJSON poiché altre librerie di prototipi potrebbero dipendere da esso.

Modifica per rendere un po 'più preciso:

Il bit chiave del problema è nella libreria JSON di JSON.org (e altre implementazioni dell'oggetto JSON di ECMAScript 5):

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

Il problema è che la libreria Prototype estende Array per includere un metodo toJSON, che l'oggetto JSON chiamerà nel codice sopra. Quando l'oggetto JSON raggiunge il valore dell'array, chiama toJSON sull'array definito in Prototype e tale metodo restituisce una versione di stringa dell'array. Quindi, le virgolette attorno alle parentesi dell'array.

Se elimini toJSON dall'oggetto Array, la libreria JSON dovrebbe funzionare correttamente. Oppure usa semplicemente la libreria JSON.

Penso che una soluzione migliore sarebbe includerla subito dopo che il prototipo è stato caricato

JSON = JSON || {};

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

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

Questo rende la funzione prototipo disponibile come JSON.stringify () e JSON.parse () standard, ma mantiene il JSON.parse () nativo se è disponibile, quindi questo rende le cose più compatibili con i browser meno recenti.

Non sono così fluente con Prototype, ma l'ho visto nei suoi documenti :

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

Non sono sicuro se questo avrebbe lo stesso problema della codifica corrente, però.

C'è anche un tutorial più lungo sull'uso di JSON con Prototype.

Questo è il codice che ho usato per lo stesso problema:

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

Controlli se Prototype esiste, quindi controlli la versione. Se la vecchia versione usa Object.toJSON (se è definito) in tutti gli altri casi fallback a JSON.stringify ()

Ecco come lo sto affrontando.

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

La mia soluzione tollerante controlla se Array.prototype.toJSON è dannoso per la stringa JSON e lo mantiene quando possibile per far funzionare il codice circostante come previsto:

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

Come le persone hanno sottolineato, ciò è dovuto a Prototype.js, in particolare alle versioni precedenti alla 1.7. Ho avuto una situazione simile ma dovevo avere un codice che funzionasse indipendentemente dal fatto che Prototype.js fosse presente o meno; questo significa che non posso semplicemente eliminare Array.prototype.toJSON perché non sono sicuro di cosa si basi su di esso. Per quella situazione questa è la migliore soluzione che ho trovato:

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

Si spera che possa aiutare qualcuno.

Se non vuoi uccidere tutto e hai un codice che andrebbe bene sulla maggior parte dei browser, puoi farlo in questo modo:

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

Sembra complesso, ma è complesso solo per gestire la maggior parte dei casi d'uso. L'idea principale è quella JSON.stringifydi rimuovere toJSONdall'oggetto passato come argomento, quindi chiamare il vecchio JSON.stringifye infine ripristinarlo.