JSON Stringify

JSON.stringify() metoda convertește a JSON-sigur Valoarea JavaScript pentru un șir compatibil JSON.

Care sunt valorile JSON-safe pe care le-ați putea întreba! Să facem o listă cu toate valorile nesigure JSON și orice lucru care nu este pe listă poate fi considerat sigur JSON.

Valori JSON nesigure:

  • undefined
  • function(){}
  • (ES6 +) Symbol
  • Un obiect cu referință circulară

Sintaxă

  JSON.stringify( value [, replacer [, space]])

În forma sa cea mai simplă și cea mai utilizată:

  JSON.stringify( value )

Parametrii

value : Valoarea JavaScript care trebuie „strânsă”.

replacer : (Opțional) O funcție sau o matrice care servește ca un filtru pentru proprietățile obiectului valoare care trebuie incluse în șirul JSON.

space : (Opțional) O valoare numerică sau șir pentru a oferi indentare șirului JSON. Dacă este furnizată o valoare numerică, multe spații (până la 10) acționează ca indentație la fiecare nivel. Dacă este furnizată o valoare a șirului, acel șir (până la primele 10 caractere) acționează ca indentare la fiecare nivel.

Tipul de returnare

Tipul de returnare al metodei este: string.

Descriere

Valorile JSON-safe sunt convertite în forma lor de șir JSON corespunzătoare. Pe de altă parte, valorile JSON-nesigure revin:

  • undefined dacă sunt transmise ca valori metodei
  • null dacă sunt transmise ca element de matrice
  • nimic dacă este trecut ca proprietăți pe un obiect
  • aruncă o eroare dacă este un obiect cu referințe circulare pe ea.
  //JSON-safe values
  JSON.stringify({});                  // '{}'
  JSON.stringify(true);                // 'true'
  JSON.stringify('foo');               // '"foo"'
  JSON.stringify([1, 'false', false]); // '[1,"false",false]'
  JSON.stringify({ x: 5 });            // '{"x":5}'
  JSON.stringify(new Date(2006, 0, 2, 15, 4, 5))  // '"2006-01-02T15:04:05.000Z"'
  
  //JSON-unsafe values passed as values to the method
  JSON.stringify( undefined );					// undefined
  JSON.stringify( function(){} );					// undefined

  //JSON-unsafe values passed as array elements
  JSON.stringify({ x: [10, undefined, function(){}, Symbol('')] });  // '{"x":[10,null,null,null]}' 
 
 //JSON-unsafe values passed as properties on a object
  JSON.stringify({ x: undefined, y: Object, z: Symbol('') });  // '{}'
  
  //JSON-unsafe object with circular reference on it
  var o = { },
    a = {
      b: 42,
      c: o,
      d: function(){}
    };

  // create a circular reference inside `a`
  o.e = a;

  // would throw an error on the circular reference
  // JSON.stringify( a );

JSON.stringify(...) se comportă diferit dacă un obiect trecut către acesta are un toJSON() metoda definită pe acesta. Valoarea returnată din toJSON() metoda va fi serializată în locul obiectului în sine.

Acest lucru este extrem de util atunci când un obiect conține orice valoare JSON ilegală.

   //JSON-unsafe values passed as properties on a object
   var obj = { x: undefined, y: Object, z: Symbol('') };
   
   //JSON.stringify(obj);  logs '{}'
   obj.toJSON = function(){
    return {
      x:"undefined",
      y: "Function",
      z:"Symbol"
    }
   }
   JSON.stringify(obj);  //"{"x":"undefined","y":"Function","z":"Symbol"}"
    
  //JSON-unsafe object with circular reference on it
  var o = { },
    a = {
      b: 42,
      c: o,
      d: function(){}
    };

  // create a circular reference inside `a`
  o.e = a;

  // would throw an error on the circular reference
  // JSON.stringify( a );
  
  // define a custom JSON value serialization
  a.toJSON = function() {
    // only include the `b` property for serialization
    return { b: this.b };
  };

  JSON.stringify( a ); // "{"b":42}"

replacer

replacer, așa cum am menționat mai devreme, este un filtru care indică care sunt proprietățile care trebuie incluse în șirul JSON. Poate fi fie o matrice, fie o funcție. Atunci când o matrice, înlocuitorul conține reprezentările șirului numai acelor proprietăți care urmează să fie incluse în șirul JSON.

  var foo = {foundation: 'Mozilla', model: 'box', week: 45, transport: 'car', month: 7};
  JSON.stringify(foo, ['week', 'month']);    // '{"week":45,"month":7}', only keep "week" and "month" properties

Dacă replacer este o funcție, va fi apelată o dată pentru obiectul în sine, și apoi o dată pentru fiecare proprietate din obiect și de fiecare dată sunt transmise două argumente, cheie și valoare. Pentru a sări peste un cheie în serializare, undefined ar trebui returnate. În caz contrar, valoare cu condiția să fie returnate. Dacă oricare dintre acestea valori sunt obiecte în sine, replacer funcția le serializează și recursiv.

  function replacer(key, value) {
    // Filtering out properties
    if (typeof value === 'string') {
      return undefined;
    }
    return value;
  }

  var foo = {foundation: 'Mozilla', model: 'box', week: 45, transport: 'car', month: 7};
  JSON.stringify(foo, replacer);  // '{"week":45,"month":7}'

Dacă o matrice este transmisă către JSON.stringify() și replacer se intoarce undefined pentru oricare dintre elementele sale, valoarea elementului este înlocuită cu null. replacer funcțiile nu pot elimina valorile dintr-o matrice.

  function replacer(key, value) {
    // Filtering out properties
    if (typeof value === 'string') {
      return undefined;
    }
    return value;
  }

  var foo = ['Mozilla', 'box', 45, 'car', 7];
  JSON.stringify(foo, replacer);  // "[null,null,45,null,7]"

space

space parametrul folosit pentru indentare face ca rezultatul JSON.stringify() mai frumoasă.

  var a = {
    b: 42,
    c: "42",
    d: [1,2,3]
  };

  JSON.stringify( a, null, 3 );
  // "{
  //    "b": 42,
  //    "c": "42",
  //    "d": [
  //       1,
  //       2,
  //       3
  //    ]
  // }"

  JSON.stringify( a, null, "-----" );
  // "{
  // -----"b": 42,
  // -----"c": "42",
  // -----"d": [
  // ----------1,
  // ----------2,
  // ----------3
  // -----]
  // }"

JSON Parse

JSON.parse() metoda analizează un șir și construiește un nou obiect descris de un șir.

Sintaxă:

    JSON.parse(text [, reviver])

Parametri:

text Șirul de analizat ca JSON

reviver(Opțional) Funcția va primi key și value ca argumente. Această funcție poate fi utilizată pentru a transforma valoarea rezultatului.

Iată un exemplu despre modul de utilizare JSON.parse():

var data="{"foo": "bar"}";

console.log(data.foo); // This will print `undefined` since `data` is of type string and has no property named as `foo`

// You can use JSON.parse to create a new JSON object from the given string
var convertedData = JSON.parse(data);

console.log(convertedData.foo); // This will print `bar

Repl.it Demo

Iată un exemplu cu reviver:

var data="{"value": 5}";

var result = JSON.parse(data, function(key, value) {
    if (typeof value === 'number') {
        return value * 10;
    }
    return value;
});

// Original Data
console.log("Original Data:", data); // This will print Original Data: {"value": 5}
// Result after parsing
console.log("Parsed Result: ", result); // This will print Parsed Result:  { value: 50 }

În exemplul de mai sus, toate valorile numerice sunt multiplicate cu 10Repl.it Demo

Mai multe informații despre JSON:

  • Sintaxa JSON
  • Transformați site-ul dvs. într-o aplicație mobilă cu 7 linii de JSON