Métodos JavaScript JSON, toJSON

La Notación de Objetos de JavaScript (JSON) es un formato notable para representar objetos y valores. Inicialmente, este formato fue creado para JavaScript, pero varios lenguajes también incluyen bibliotecas para manejarlo. Por lo tanto, es más fácil usar JSON para el intercambio de datos en caso de que el cliente utilice JavaScript, y el servidor esté escrito en PHP, Ruby, Java, entre otros.

En general, JavaScript proporciona dos métodos de conversión: JSON.stringify y JSON.parse. Puedes usar el primero para convertir objetos en JSON y el segundo para convertir JSON de nuevo en un objeto.

JSON.stringify

Consideremos el siguiente ejemplo de uso de JSON.stringify:

JSON stringify in javascript
let site = { name: 'W3Docs', hasAdmin: true, books: ['html', 'css', 'js', 'git'], booksCount: 4, }; let json = JSON.stringify(site); console.log(typeof json); // we've got a string! console.log(json); /* JSON-encoded object: { "name": "W3Docs", "hasAdmin": true, "books": ["html", "css", "js", "git"], "booksCount": 4 } */

Por favor, ten en cuenta que un objeto codificado en JSON difiere del objeto literal. Las principales diferencias son las siguientes:

  1. La cadena utiliza comillas dobles. No debería haber comillas simples ni acentos graves en JSON. Por ejemplo, 'W3Docs' se convierte en "W3Docs".
  2. Las comillas dobles también deben usarse para los nombres de propiedades de objetos. Es obligatorio. Por ejemplo, booksCount : 4 se convertirá en "booksCount": 4.

Puedes aplicar el método JSON.stringify también a primitivas. Soporta los siguientes tipos de datos:

Aquí hay un ejemplo:

JSON stringify in javascript
// a JSON number is an ordinary number console.log(JSON.stringify(10)) // 10 // a JSON string is a double-quoted string console.log(JSON.stringify([1, 2, 3])); // [1,2,3] console.log(JSON.stringify(false)); // false console.log(JSON.stringify('W3Docs')) // "W3Docs"

Observa que JSON.stringify omite varios objetos específicos de JavaScript, como las propiedades de función (métodos), las propiedades simbólicas y las propiedades que almacenan undefined.

Comprobemos el siguiente caso:

JSON stringify in javascript
let site = { welcome() { // ignore console.log("Welcome"); }, [Symbol("id")]: 10, // ignore someProperty: undefined // ignore }; console.log(JSON.stringify(site)); // {} - empty object

Lo mejor de esto es que los objetos anidados son automáticamente soportados y convertidos.

Por ejemplo:

JSON stringify with nested objects javascript
let site = { name: "W3Docs", books: { booksCount: 4, booksTitle: ["html", "css", "js", "git"] } }; console.log(JSON.stringify(site)); /* The whole structure is stringified: { "name":"W3Docs", "book":{"booksCount":4,"booksTitle":["html","css", "js", "git"]}, } */

Pero, también hay una limitación esencial: no debes usar referencias circulares.

Por ejemplo:

Javascript json stringify objects not use circular references
let books = { booksCount: 4 }; let site = { name: "W3Docs", booksTitle: ["html", "css", "js", "git"] }; site.tutorial = books; // site references books books.canUse = site; // books references site console.log(JSON.stringify(site)); // Error: Converting circular structure to JSON

Exclusión y Transformación: replacer

Para JSON.stringify se utiliza la siguiente sintaxis completa:

let json = JSON.stringify(value[, replacer, space])

Tiene tres argumentos:

  • el valor: un valor para codificar;
  • el replacer: el array de propiedades para codificar o una función de mapeo function(key, value);;
  • el espacio: cantidad de espacio que se utiliza para formatear.

La mayoría de las veces, JSON.stringify usa el primer argumento. Pero si quieres mejorar tu proceso de reemplazo, también puedes usar el segundo argumento. Si se le pasa un array de propiedades, solo estas propiedades se codificarán.

Veamos el ejemplo:

JSON stringify in javascript
let books = { booksCount: 4 }; let site = { name: "W3Docs", booksTitle: [{ title: "html" }, { title: "css" }, { title: "js" }, { title: "git" }], tutorial: books // tutorial references books }; books.canUse = site; // books references site console.log(JSON.stringify(site, ['name', 'booksTitle'])); // {"name":"W3Docs","booksTitle":[{},{},{},{}]}
JSON stringify javascript
let books = { booksCount: 4 }; let site = { name: "W3Docs", booksTitle: [{ title: "html" }, { title: "css" }, { title: "js" }, { title: "git" }], tutorial: books // site references books }; books.canUse = site; //books references site console.log(JSON.stringify(site, ['name', 'booksTitle', 'tutorial', 'title', 'booksCount'])); /* { "name":"W3Docs", "booksTitle":[{"title":"html"},{"title":"css"}, {"title":"js"}, {"title":"git"}], "tutorial":{"booksCount":4} } */

Ahora, intentemos añadir en la lista todas las propiedades, excluyendo books.free:

Como puedes ver, todo se serializa, excepto canUse. También puedes notar que la lista dada parece bastante larga. Afortunadamente, se puede llamar a la función replacer. Puedes llamarla para cada par key, value, y el valor “reemplazado” puede ser devuelto. Puedes usarlo en lugar del valor original. Para ignorar el canUse el undefined es devuelto en el ejemplo de abajo:

JSON stringify in javascript
let books = { booksCount: 4 }; let site = { name: "W3Docs", booksTitle: [{ title: "html" }, { title: "css" }, { title: "js" }, { title: "git" }], tutorial: books // site references books }; books.canUse = site; // books references site console.log(JSON.stringify(site, function replacer(key, value) { console.log(`${key}: ${value}`); return (key == 'canUse') ? undefined : value; })); /* key:value pairs that come to replacer: : [object Object] name: W3Docs booksTitle: [object Object],[object Object],[object Object],[object Object] 0: [object Object] title: html 1: [object Object] title: css 2: [object Object] title: js 3: [object Object] title: git tutorial: [object Object] booksCount: 4 */

Ten en cuenta que la función replacer recibe cualquier par clave/valor junto con los elementos del array y los objetos anidados.

Formato: espacio

Como se mencionó anteriormente, JSON.stringify tiene tres argumentos. El tercero es el número de espacios utilizados para el formateo. Comúnmente, los desarrolladores utilizan el argumento space para obtener una excelente salida.

El space = 2 ordena a JavaScript a mostrar los objetos anidados en varias líneas con una indentación de dos espacios dentro de un objeto.

Por ejemplo:

JSON stringify javascript
let user = { name: "Maria", age: 23, roles: { isAdmin: true, isContentWriter: false } }; console.log(JSON.stringify(user, null, 2)); /* two-space indents: { "name": "Maria", "age": 23, "roles": { "isAdmin": true, "isContentWriter": false } } */ /* for JSON.stringify(user, null, 2) the result would be more indented: { name: "Maria", age: 23, roles: { isAdmin: true, isContentWriter: false } }; */

Personalizado “toJSON”

Como regla general, un objeto puede proporcionar el método toJSON para implementar la conversión a toJSON. Si está disponible, JSON.stringify lo llama automáticamente.

Aquí tienes un ejemplo:

JSON stringify javascript
let books = { booksCount: 4 }; let site = { name: "W3Docs", update: new Date(Date.UTC(2020, 1, 2)), books }; console.log(JSON.stringify(site)); /* { "name":"W3Docs", "update":"2020-02-02T00:00:00.000Z", // (1) "books": {"booksCount":4 } // (2) } */

En el caso anterior, la actualización (1) se transforma en una cadena. La razón es que todas las fechas tienen un método toJSON integrado.

Si agregas un toJSON personalizado para el objeto books (2), se verá de la siguiente manera:

toJSON in javascript
let books = { booksCount: 4, toJSON() { return this.booksCount; } }; let site = { name: "W3Docs", books }; console.log(JSON.stringify(books)); // 4 console.log(JSON.stringify(site)); /* { "name":"W3Docs", "books": 4 } */

JSON.parse

Para decodificar una cadena JSON se utiliza otro método, llamado JSON.parse con la siguiente sintaxis:

let value = JSON.parse(str, [reviver]);

JSON es algo complicado: los objetos y los arrays pueden incluir otros objetos y arrays. Pero es obligatorio obedecer el formato de JSON.

A continuación, puedes encontrar los errores típicos en JSON escrito a mano:

let json = `{
  welcome: "Welcome",                     // mistake: property name without quotes
  "site": 'W3Docs',               // mistake: single quotes in value (must be double)
  'hasAdmin': true                  // mistake: single quotes in key (must be double)
  "update": new Date(2000, 2, 3), // mistake: no "new" is allowed, only bare values
  "books": [1, 2, 3, 4]              // here all fine
}`;

También, ten en cuenta que JSON no permite comentar. En caso de que agregues un comentario, lo harás inválido. Hay un formato único JSON, que soporta claves sin comillas, comentarios y más.

Resumen

JSON representa un formato de datos con un estándar independiente y bibliotecas para la mayoría de los lenguajes de programación. Soporta arrays, cadenas, objetos, booleanos, números y null.

JavaScript tiene los métodos JSON.stringify para serializar a JSON y JSON.parse para leer desde JSON. En caso de que un objeto tenga toJSON, necesitas llamarlo con JSON.stringify..

Hora del Cuestionario: ¡Pon a Prueba Tus Habilidades!

¿Listo para desafiar lo que has aprendido? Sumérgete en nuestros cuestionarios interactivos para una comprensión más profunda y una forma divertida de reforzar tu conocimiento.

¿Te resulta útil?