Inverser de JSON.stringify?

Question

Je suis en train de transformer un objet en chaîne comme {'foo': 'bar'}

Comment puis-je reconvertir la chaîne en objet ?

Answer 1

Vous devez JSON.parse() votre chaîne JSON valide.

var str = '{"hello":"world"}';
try {
  var obj = JSON.parse(str); // c'est ainsi que vous analysez une chaîne en JSON
  document.body.innerHTML += obj.hello;
} catch (ex) {
  console.error(ex);
}

Answer 2

JSON.parse est l'opposé de JSON.stringify.

Answer 3

JSON.stringify et JSON.parse sont presque opposés, et "généralement" ce genre de chose fonctionnera :

var obj = ...;
var json = JSON.stringify(obj);  
var obj2 = JSON.parse(json);

de sorte que obj et obj2 sont "les mêmes".

Cependant, il y a certaines limitations dont il faut être conscient. Souvent, ces problèmes n'ont pas d'importance car vous traitez avec des objets simples. Mais je vais en illustrer quelques-uns ici, en utilisant cette fonction d'aide :

function jsonrepack( obj ) { return JSON.parse(JSON.stringify(obj) ); }

• Vous n'obtiendrez que les ownProperties de l'objet et perdrez les prototypes :

  var MyClass = function() { this.foo="foo"; } 
  MyClass.prototype = { bar:"bar" }
  
  var o = new MyClass();
  var oo = jsonrepack(o);
  console.log(oo.bar); // undefined
  console.log( oo instanceof MyClass ); // false

• Vous perdrez l'identité :

  var o = {};
  var oo = jsonrepack(o);
  console.log( o === oo ); // false

• Les fonctions ne survivent pas :

  jsonrepack( { f:function(){} } ); // Retourne {}

• Les objets Date finissent en tant que chaînes de caractères :

  jsonrepack(new Date(1990,2,1)); // Retourne '1990-02-01T16:00:00.000Z'

• Les valeurs undefined ne survivent pas :

  var v = { x:undefined }
  console.log("x" in v);              // true
  console.log("x" in jsonrepack(v));  // false

• Les objets qui fournissent une fonction toJSON peuvent ne pas se comporter correctement.

  x = { f:"foo", toJSON:function(){ return "EGAD"; } }
  jsonrepack(x) // Retourne 'EGAD'

Je suis sûr qu'il y a des problèmes avec d'autres types intégrés aussi. (Tout cela a été testé en utilisant node.js donc vous pouvez obtenir un comportement légèrement différent en fonction de votre environnement aussi).

Quand cela importe, il est parfois possible de le surmonter en utilisant les paramètres supplémentaires de JSON.parse et JSON.stringify. Par exemple :

function MyClass (v) {
   this.date = new Date(v.year,1,1);
   this.name = "un objet";
};

MyClass.prototype.dance = function() {console.log("Je danse"); }

var o = new MyClass({year:2010});
var s = JSON.stringify(o);

// Fonction d'extraction intelligente
var o2 = JSON.parse( s, function(k,v){
  if(k==="") { 
     var rv = new MyClass(1990,0,0);
     rv.date = v.date;
     rv.name = v.name;
     return rv
  } else if(k==="date") {
    return new Date( Date.parse(v) );
  } else { return v; } } );

console.log(o);             // { date: , name: 'un objet' }
console.log(o.constructor); // [Function: MyClass]
o.dance();                  // Je danse

console.log(o2);            // { date: , name: 'un objet' }
console.log(o2.constructor) // [Function: MyClass]        
o2.dance();                 // Je danse

Answer 4

Il est recommandé d'utiliser JSON.parse

Il existe une alternative que vous pouvez faire :

 var myObject = eval('(' + myJSONtext + ')');

Json en javascript

Pourquoi utiliser la fonction eval de JavaScript est une mauvaise idée?

Answer 5

Que diriez-vous de ceci

var parsed = new Function('return ' + stringifiedJSON )();

Ceci est une alternative plus sûre pour eval.

var stringifiedJSON = '{"hello":"world"}';
var parsed = new Function('return ' + stringifiedJSON)();
alert(parsed.hello);