freeCodeCamp/guide/portuguese/javascript/standard-objects/json/json-stringify/index.md

title, localeTitle

title	localeTitle
JSON Stringify	JSON Stringify

JSON Stringify

O método JSON.stringify() converte um valor JavaScript JSON-safe em uma string compatível com JSON.

Quais são os valores seguros para JSON que alguém pode perguntar! Vamos fazer uma lista de todos os valores não seguros de JSON e qualquer coisa que não esteja na lista pode ser considerada segura para JSON.

Valores não seguros de JSON:

• undefined
• function(){}
• (ES6 +) Symbol
• Um objeto com referência (s) circular (ais) nele

Sintaxe

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

Na sua forma mais simples e mais utilizada:

  JSON.stringify( value ) 

Parâmetros

value : o valor do JavaScript a ser 'stringificado'.

replacer : (Opcional) Uma função ou uma matriz que serve como um filtro para propriedades do objeto de valor a ser incluído na sequência JSON.

space : (Opcional) Um valor numérico ou de cadeia para fornecer recuo à cadeia JSON. Se um valor numérico é fornecido, muitos espaços (até 10) atuam como indentação em cada nível. Se um valor de string for fornecido, essa string (até os 10 primeiros caracteres) atua como recuo em cada nível.

Tipo de retorno

O tipo de retorno do método é: string .

Descrição

Os valores seguros para JSON são convertidos em seus respectivos formatos de string JSON. Os valores não seguros do JSON, por outro lado, retornam:

• undefined se forem passados ​​como valores para o método
• null se eles forem passados ​​como um elemento de matriz
• nada se passado como propriedades em um objeto
• lança um erro se for um objeto com referências circulares nele.

  //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` 
  oe = a; 
 
  // would throw an error on the circular reference 
  // JSON.stringify( a ); 

JSON.stringify(...) se comporta de maneira diferente se um objeto passado a ele tiver um método toJSON() definido nele. O valor de retorno do método toJSON() será serializado em vez do próprio objeto.

Isso é excepcionalmente útil quando um objeto contém qualquer valor 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` 
  oe = 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}" 

O replacer

O replacer , como mencionado anteriormente, é um filtro que indica quais propriedades devem ser incluídas na sequência JSON. Pode ser uma matriz ou uma função. Quando um array, o replacer contém as representações de string apenas daquelas propriedades que devem ser incluídas na string 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 

Se replacer for uma função, ela será chamada uma vez para o próprio objeto e, em seguida, uma vez para cada propriedade no objeto, e cada vez que receber dois argumentos, chave e valor . Para pular uma chave na serialização, undefined deve ser retornado. Caso contrário, o valor fornecido deve ser retornado. Se algum desses valores forem objetos propriamente ditos, a função de replacer serializará recursivamente.

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

Se uma matriz for passada para JSON.stringify() e o replacer retornar undefined para qualquer um dos seus elementos, o valor do elemento será substituído por null . funções de replacer não podem remover valores de uma matriz.

  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]" 

O space

O parâmetro de space usado para recuo torna o resultado de JSON.stringify() mais bonito.

  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 
  // -----] 
  // }" 

Mais Informações:

Consulte os documentos do MDN .