JSON en JavaScript: parse y stringify con ejemplos

Para trabajar con JSON en JavaScript utiliza JSON.parse() para convertir un texto JSON en un valor del lenguaje y JSON.stringify() para generar texto JSON a partir de un valor compatible.

JSON es un formato de intercambio de datos. Se parece a la escritura de objetos en JavaScript, pero sus reglas son distintas: no admite funciones, comentarios ni comas finales.

Ejemplo de un documento JSON válido

{
  "nombre": "Ana",
  "activo": true,
  "edad": 28,
  "cursos": ["HTML", "JavaScript"],
  "telefono": null
}

Las claves y las cadenas utilizan comillas dobles. JSON también puede representar un array, un número, un booleano, una cadena o null como valor raíz; no se limita a objetos.

JSON.parse: convertir texto en datos

const texto = '{"nombre":"Ana","edad":28}';
const usuario = JSON.parse(texto);
console.log(usuario.nombre); // Ana
console.log(typeof usuario); // object

En el código, las comillas simples delimitan la cadena JavaScript; dentro se conserva el JSON con comillas dobles. Parse no «consulta una API»: solo interpreta el texto que le entregas.

JSON.stringify: convertir datos en texto

const usuario = { nombre: "Ana", cursos: ["HTML", "CSS"] };
const texto = JSON.stringify(usuario);
console.log(texto);
// {"nombre":"Ana","cursos":["HTML","CSS"]}

console.log(JSON.stringify(usuario, null, 2)); // Presentación con sangría

La sangría resulta cómoda para leer ejemplos y archivos. No es necesaria para que un receptor interprete el documento.

Cómo manejar JSON inválido y validar su estructura

function leerPerfil(texto) {
  try {
    const dato = JSON.parse(texto);
    if (dato === null || Array.isArray(dato) ||
        typeof dato !== "object" ||
        typeof dato.nombre !== "string") {
      return null;
    }
    return { nombre: dato.nombre };
  } catch {
    return null;
  }
}

console.log(leerPerfil('{"nombre":"Ana"}')); // { nombre: "Ana" }
console.log(leerPerfil('{"nombre":123}')); // null
console.log(leerPerfil('texto incorrecto')); // null

Un JSON sintácticamente correcto puede contener datos que tu programa no espera. Por eso son dos pasos distintos: parsear y comprobar el contrato de datos.

Información que no se conserva igual

JSON no representa todos los tipos de JavaScript. Las funciones y undefined no se serializan como propiedades normales de un objeto; algunos valores no representables se convierten en null en arrays. Un BigInt provoca un error de forma predeterminada y las referencias circulares también requieren otro tratamiento.

Una fecha puede serializarse como cadena, pero parse no la convierte automáticamente de nuevo en un objeto Date. Tampoco recupera por sí solo instancias de clases, Map o Set con su comportamiento original.

Por qué no usarlo como copia profunda universal

El patrón de stringify seguido de parse solo sirve para datos compatibles y pierde información de otros tipos. Para clonar datos, estudia las necesidades reales y las opciones disponibles, como structuredClone para tipos compatibles. No lo sustituyas mecánicamente en cualquier objeto.

Errores frecuentes

• Comillas simples en el contenido JSON.
• Una coma detrás de la última propiedad.
• Llamar parse sobre un objeto que ya está convertido.
• Confiar en los datos sin comprobar su estructura.

Preguntas frecuentes

¿Debo usar eval para leer JSON?

No. Utiliza JSON.parse; no ejecutes texto recibido como código.

¿JSON sirve para enviar datos?

Sí, cuando el servidor o receptor admite ese formato. Debes respetar las cabeceras y el contrato del servicio.

Repasa las bases de JavaScript y utiliza datos pequeños para probar la conversión en la consola.

Referencia técnica: documentación de MDN.