Las reglas de JSON
JSON (JavaScript Object Notation) se parece a un objeto literal, pero es más estricto:
- Las claves van siempre entre comillas dobles:
"nombre". - Los textos, también con comillas dobles. Nada de comillas simples ni template literals.
- Valores permitidos: textos, números,
true,false,null, arrays y objetos. No hayundefined, funciones, fechas,NaNniInfinity. - Sin comas al final ni comentarios.
{
"nombre": "Ana",
"edad": 31,
"lenguajes": ["JavaScript", "Python"],
"jefe": null
}
De objeto a texto y de vuelta
const usuario = { nombre: "Ana", edad: 31, activo: true };
const texto = JSON.stringify(usuario); // objeto → texto
console.log(texto);
console.log(typeof texto);
const deVuelta = JSON.parse(texto); // texto → objeto nuevo
console.log(deVuelta.nombre);
JSON.parse devuelve un objeto nuevo: por eso el viejo truco JSON.parse(JSON.stringify(obj)) servía para copiar, con las pérdidas que viste en Copias superficiales y profundas.
Para que el texto sea legible por humanos, pasa la sangría como tercer argumento:
const config = { tema: "oscuro", atajos: { guardar: "Ctrl+S" } };
console.log(JSON.stringify(config, null, 2));
Lo que se pierde
Al convertir a texto, lo que JSON no sabe representar se adapta o desaparece:
| Valor | En un objeto | En un array |
|---|---|---|
undefined, funciones, símbolos |
La propiedad desaparece | null |
NaN, Infinity |
null |
null |
Date |
Texto ISO ("2026-11-20T…") |
Texto ISO |
Map, Set |
{} vacío |
{} vacío |
Recuperar fechas y personalizar
JSON.parse acepta una función reviver que recibe cada clave y valor y puede transformarlos. Es la forma de recuperar fechas:
const texto = '{"evento":"Charla","fecha":"2026-11-20T18:00:00.000Z"}';
const datos = JSON.parse(texto, (clave, valor) =>
clave === "fecha" ? new Date(valor) : valor
);
console.log(datos.fecha instanceof Date); // true
console.log(datos.fecha.getUTCHours()); // 18
Al revés, si un objeto tiene un método toJSON, stringify usa lo que devuelve:
const cuenta = {
usuario: "ana",
clave: "secreta",
toJSON() {
return { usuario: this.usuario }; // nunca exportes la clave
},
};
console.log(JSON.stringify(cuenta));
Leer JSON sin romperse
JSON.parse lanza un SyntaxError si el texto no es JSON válido. Con datos que vienen de afuera (un archivo, localStorage, una red), siempre pueden llegar rotos:
function leer(texto) {
try {
return JSON.parse(texto);
} catch (error) {
console.log("JSON inválido:", error.name);
return null;
}
}
console.log(leer('{"ok": true}'));
console.log(leer("{ok: true}"));
Módulos JSON (ES2025)
Desde ES2025 puedes importar un archivo JSON directamente, ya convertido en objeto. El atributo with { type: "json" } le dice al runtime que el archivo es JSON y no código:
// config.json: { "version": "2.1", "debug": false }
import config from "./config.json" with { type: "json" };
console.log(config.version);
Funciona en los navegadores modernos, Node.js, Deno y Bun. Antes había que leer el archivo y pasarlo por JSON.parse, o usar fetch.
Resumen
- JSON es texto con forma de objeto: comillas dobles, sin funciones ni
undefined. JSON.stringifyconvierte a texto;JSON.parse, de texto a un valor nuevo.- Se pierden
undefinedy funciones; las fechas pasan a texto. Recupéralas con un reviver. toJSONdecide cómo se exporta un objeto.- Envuelve
JSON.parseentry/catchcuando los datos vienen de afuera. - ES2025:
import datos from "./datos.json" with { type: "json" }.
¡A practicar!
Tu progreso se guarda en este navegador.
Autoevaluación: Texto con forma de objeto
Resuelto
Elige una respuesta en cada pregunta.
¿Qué devuelve
JSON.stringify({ a: 1 })?¿Cuál de estos textos es JSON válido?
¿Qué pasa con una fecha al hacer
JSON.parse(JSON.stringify({ d: new Date() }))?¿Qué hace
import config from "./config.json" with { type: "json" }?
Ordena la salida: Lo que JSON no guarda
Resuelto
Un objeto con valores que JSON no sabe guardar. Ordena lo que aparecería en la consola.
1const datos = { a: 1, b: undefined, c: () => 1, d: NaN, e: [undefined] };2 3console.log(JSON.stringify(datos));4console.log(JSON.stringify("hola"));5console.log(JSON.parse("[1, 2]").length);6console.log(typeof JSON.parse("true"));Consola, de arriba abajo
- 2
- {"a":1,"d":null,"e":[null]}
- boolean
- "hola"
En un objeto, las propiedades con undefined o funciones desaparecen; NaN se convierte en null, y dentro de un array, undefined también. Un texto se guarda con sus comillas. parse acepta cualquier valor JSON, no solo objetos.
Detective: Un JSON con comillas simples
Resuelto
JSON.parse se queja, pero el problema no está en esa línea. Encuentra la culpable y elige el arreglo.
Consola
usuario.js:2
const usuario = JSON.parse(texto);
^
SyntaxError: Expected property name or '}' in JSON at position 1 (line 1 column 2)Paso 1: toca la línea de código que causa el error.
Paso 2: ¿cómo lo arreglas?
Laboratorio: Leer sin romperse
Resuelto
Escribe leerConfig(texto): si el texto es JSON válido, devuelve el objeto; si no, un objeto vacío, sin lanzar errores.
$ node programa.js
Lo que debe cumplir
- Imprime
oscuroy después{}(pendiente) - Con un texto vacío devuelve
{}sin lanzar error (pendiente) - Usa
JSON.parsedentro de untry(pendiente)
Una solución
1function leerConfig(texto) {2 try {3 return JSON.parse(texto);4 } catch {5 return {};6 }7}8 9console.log(leerConfig('{"tema": "oscuro"}').tema);10console.log(leerConfig("{tema: oscuro}"));Todo JSON que viene de afuera (un archivo, localStorage, una respuesta de red) puede llegar roto. Envolver el JSON.parse en un try/catch con un valor de respaldo evita que un dato malo tumbe todo el programa.