Un diccionario (u objeto) y una lista (o arreglo) no son parte de JSON como tal. JSON es un formato de texto. Un objeto o un arreglo solo aparece cuando un programa analiza ese texto y lo convierte en una estructura del lenguaje. En JavaScript, JSON.parse devuelve un objeto nativo si la raíz del documento es un objeto JSON, y un array nativo si es un arreglo JSON. Por eso la pregunta “¿JSON es lo mismo que un objeto de JavaScript?” tiene una respuesta corta: no, pero se convierten el uno en el otro con mucha facilidad, siempre que los datos encajen en lo que JSON puede expresar.
Dos capas: el texto JSON y el valor que se obtiene al analizarlo
Conviene separar siempre dos cosas. La primera es el texto, una cadena de caracteres que viaja por una red, se guarda en un archivo o llega como respuesta de una API. La segunda es el valor en memoria que el lenguaje construye a partir de ese texto. El texto no tiene propiedades que se puedan leer con un punto ni posiciones a las que se pueda acceder por índice; esas operaciones solo existen sobre el valor ya analizado.
As an Amazon Associate I earn from qualifying purchases.
Este texto JSON tiene un objeto raíz. Dentro, usuario es un objeto anidado y etiquetas es un arreglo:
{"usuario":{"nombre":"Ana","activo":true},"etiquetas":["nuevo","json"]}Tras analizarlo en JavaScript, el resultado se usa como cualquier otro objeto y cualquier otro array:
#1 Best Overall
const texto = '{"usuario":{"nombre":"Ana","activo":true},"etiquetas":["nuevo","json"]}';
const datos = JSON.parse(texto);
console.log(datos.usuario.nombre); // "Ana"
console.log(datos.etiquetas[1]); // "json"
console.log(Array.isArray(datos.etiquetas)); // trueCómo pasar de texto a estructuras y de vuelta
El flujo habitual tiene cuatro pasos. Cada uno corresponde a una función de la API JSON que MDN Web Docs documenta para JavaScript.
- Obtener el texto. Puede venir de una respuesta HTTP, de un archivo o de un campo de texto en una base de datos. Todavía no es un objeto.
- Analizarlo con
JSON.parse(texto). Si el texto no es JSON válido, la llamada lanza unSyntaxError. - Trabajar con el valor resultante. Se leen propiedades con
datos.usuario.nombrey elementos condatos.etiquetas[0], igual que con cualquier estructura de JavaScript. - Serializar de nuevo con
JSON.stringify(valor). Devuelve texto JSON, que puede enviarse o guardarse.
datos.etiquetas.push("api");
const salida = JSON.stringify(datos);
// '{"usuario":{"nombre":"Ana","activo":true},"etiquetas":["nuevo","json","api"]}'Dos detalles de este ejemplo importan. El orden de las claves se conserva, y el espacio de nombres de la salida es texto puro, de modo que cualquier lenguaje que sepa leer JSON puede procesarlo.
Qué puede representar JSON y qué no
La gramática de JSON es deliberadamente pequeña. Estos son los tipos que admite y los que no tienen sintaxis propia:
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Fix the driver behind crashes, sound loss and screen glitches3Repair Windows errors before they cause bigger problems| Tipo | ¿Tiene representación en JSON? | Observación |
|---|---|---|
| Cadena | Sí | Entre comillas dobles, con escapes como n o ". |
| Número | Sí | Sin distinción entre enteros y decimales en el texto; ver la sección sobre precisión. |
true y false |
Sí | Booleanos en minúsculas. |
null |
Sí | Es el único valor “vacío” que JSON define. |
| Objeto | Sí | Pares nombre/valor entre llaves; pueden anidarse. |
| Arreglo | Sí | Valores ordenados entre corchetes; pueden anidarse. |
undefined, funciones, NaN, Infinity |
No | Ninguna sintaxis JSON los expresa; ver la tabla de serialización. |
Date, Map, Set |
No | Sin tipo propio en JSON; se requiere una convención explícita. |
Como el documento JSON puede tener un objeto, un arreglo o un valor primitivo como raíz, JSON.parse("42") devuelve el número 42 y no un objeto. Un programa que espere siempre un diccionario debe comprobar el tipo antes de acceder a sus propiedades.
Rank #2
Sintaxis: lo que parece JavaScript pero no es JSON
Muchos errores vienen de copiar un literal de JavaScript y pegarlo como si fuera JSON. Las reglas de JSON son más estrictas:
- Los nombres de propiedad y las cadenas van entre comillas dobles. Las comillas simples no son válidas.
- No se admiten comentarios de ningún tipo.
- No se admite coma final después del último elemento de un objeto o de un arreglo.
// Literal válido en JavaScript, pero no es JSON
const literal = { nombre: 'Ana', activo: true, };
// Ambos lanzan SyntaxError
JSON.parse("{nombre: 'Ana'}");
JSON.parse('{"nombre":"Ana",}');
// Forma válida
JSON.parse('{"nombre":"Ana","activo":true}');Si JSON.parse falla, revise en este orden: comillas simples o claves sin comillas, comas finales, comentarios pegados desde código, y saltos de línea o caracteres de control sin escapar dentro de una cadena. El mensaje del error suele indicar la posición aproximada del problema.
Qué cambia al serializar con JSON.stringify
Serializar no es una copia exacta. JSON no tiene representación para algunos valores, y JSON.stringify aplica reglas fijas que varían según el lugar donde aparezca el valor. Esta tabla resume el comportamiento documentado por MDN Web Docs:
The Tool Desk
Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →| Valor | Como propiedad de un objeto | Como elemento de un arreglo |
|---|---|---|
undefined |
Se omite la propiedad | Se escribe null |
| Función | Se omite la propiedad | Se escribe null |
| Símbolo | Se omite la propiedad | Se escribe null |
NaN e Infinity |
Se escribe null |
Se escribe null |
JSON.stringify({ a: undefined, b: () => 1, c: NaN, d: [undefined, () => 1, NaN] });
// '{"c":null,"d":[null,null,null]}'La consecuencia práctica es que la propiedad a desaparece del texto, mientras que la posición del arreglo d se conserva con null. Si el sistema receptor distingue entre “ausente” y “nulo”, ese cambio puede romper la lógica. Conviene documentar qué convención usa cada extremo.
Cuando un objeto de JavaScript no sobrevive al viaje
La mayoría de los fallos de “se perdieron datos” no son errores de JSON, sino expectativas sobre tipos que JSON no representa. Son tres casos frecuentes.
Map y Set
Un Map o un Set no tienen propiedades enumerables que JSON pueda recoger, así que se serializan como un objeto vacío:
JSON.stringify(new Map([["a", 1]])); // "{}"Para conservarlos hay que convertirlos antes de serializar. Un replacer puede hacerlo de forma general:
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →const mapa = new Map([["a", 1], ["b", 2]]);
JSON.stringify(mapa, (clave, valor) =>
valor instanceof Map ? Object.fromEntries(valor) : valor
); // '{"a":1,"b":2}'Al leer, el resultado será un objeto plano; si la aplicación necesita un Map otra vez, debe construirlo explícitamente.
Rank #4
Fechas
Un Date sí se serializa, pero como cadena en formato ISO, porque tiene un método toJSON. Al analizar el texto, esa cadena no vuelve a ser un Date de forma automática:
JSON.stringify({ fecha: new Date(0) });
// '{"fecha":"1970-01-01T00:00:00.000Z"}'
const texto = '{"fecha":"1970-01-01T00:00:00.000Z"}';
const datos = JSON.parse(texto, (clave, valor) =>
clave === "fecha" ? new Date(valor) : valor
);El reviver del ejemplo funciona solo porque la aplicación sabe que la clave fecha contiene una fecha. Ninguna regla general de JSON lo hace por sí sola.
Referencias circulares y BigInt
Dos casos lanzan TypeError en lugar de producir texto. Un objeto que se referencia a sí mismo no tiene una representación finita en JSON, y un valor BigInt necesita una conversión explícita antes de serializarse:
const nodo = {};
nodo.self = nodo;
JSON.stringify(nodo); // TypeError: circular structure
JSON.stringify({ n: 1n }); // TypeError: Do not know how to serialize a BigIntPara las referencias circulares, la solución habitual es aplanar la estructura o guardar identificadores en lugar de punteros. Para BigInt, basta con convertirlo a cadena antes de serializar, siempre que el receptor espere ese formato.
Números grandes y precisión
JavaScript representa los números como valores de coma flotante de doble precisión. Los enteros exactos llegan hasta Number.MAX_SAFE_INTEGER (9007199254740991). Por encima de ese valor, un número del texto JSON puede redondearse al analizarlo:
JSON.parse('{"id":9007199254740993}').id; // 9007199254740992Si un identificador, un importe o un contador puede superar ese límite, defina la representación con el receptor. Lo más habitual es enviarlo como cadena, por ejemplo "id":"9007199254740993", y convertirlo solo cuando haga falta operar con él.
Otros lenguajes: mismo texto, distintos nombres
Fuera de JavaScript, el texto JSON se analiza igual, pero las estructuras resultantes reciben otros nombres. Por eso conviene hablar de “objeto JSON” y “arreglo JSON” cuando se describe el documento, y de objeto, diccionario, mapa, lista o array cuando se describe el valor en un lenguaje concreto.
| Concepto en JSON | En JavaScript | En otros lenguajes |
|---|---|---|
| Objeto JSON (pares nombre/valor) | Objeto nativo | Suele analizarse como diccionario o mapa, según el lenguaje |
| Arreglo JSON (valores ordenados) | Array nativo | Suele analizarse como lista o arreglo |
Un diccionario que vuelve de otro lenguaje puede tener un orden de claves distinto, o tipos numéricos con reglas de precisión diferentes. Si el intercambio de datos debe ser estable entre sistemas, documente el esquema esperado y valide el texto contra él antes de confiar en los valores.
Cuándo JSON basta y cuándo hace falta una convención
JSON sirve bien para estructuras portables, con cadenas, números, booleanos, null, objetos y arreglos. Para clases, Map, Set, fechas o datos que requieren exactitud numérica, la aplicación debe definir una convención, como un replacer y un reviver propios, o usar un formato que modele esos tipos de forma explícita. Lo que no conviene es esperar que JSON.parse(JSON.stringify(valor)) reconstruya esas estructuras de forma automática: solo devuelve el subconjunto que JSON puede expresar.
Lectura complementaria y referencia técnica
MDN Web Docs es la referencia técnica principal para la semántica de JSON y de las API JSON.parse y JSON.stringify. Algunos comportamientos de funciones más recientes pueden variar según el entorno de ejecución, así que compruebe la compatibilidad del runtime que usa antes de depender de ellos.
Para ampliar sin entrar en detalles de implementación, el libro Beginning JSON, de Ben Smith, publicado por Apress (Springer Nature), cubre los fundamentos de JSON, su creación, el análisis y la persistencia, y se ofrece en formato electrónico e impreso según la ficha editorial. Es una lectura opcional; los conceptos de este artículo no dependen de ella.
Free tools Windows power users keep installed
One-click scans. No signup required.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
