Cómo formatear y validar JSON

Para formatear JSON, pégalo en un formateador que añada sangría y saltos de línea para que la estructura sea fácil de leer; para validarlo, pásalo por un analizador que compruebe la sintaxis y señale el punto exacto donde se rompe. Formatear (también llamado embellecer o «pretty-printing») y validar suelen ir de la mano: una buena herramienta vuelve a aplicar sangría al JSON válido y, cuando la entrada está rota, te dice con precisión qué está mal. A continuación tienes lo que hace realmente cada acción, cuándo formatear frente a minificar y cómo leer y corregir los errores que lanza un analizador.

Formatear, minificar, validar: tres tareas distintas

Estas tres palabras se usan indistintamente, pero hacen cosas diferentes con tus datos.

• Formatear (embellecer) añade sangría y saltos de línea para que los objetos y arreglos anidados queden alineados visualmente. No cambia los datos, solo los espacios en blanco, lo que facilita muchísimo revisar a simple vista un archivo de configuración o una respuesta de API.
• Minificar hace lo contrario: elimina cada espacio, tabulación y salto de línea no esencial para que la carga útil sea lo más pequeña posible. Los datos son idénticos, solo que comprimidos en lo que es prácticamente una sola línea.
• Validar comprueba si el texto es siquiera JSON legal. Un validador analiza la entrada y confirma que está bien formada o informa del primer error de sintaxis que encuentra.

En la práctica, formateas mientras lees y depuras, y minificas justo antes de enviar datos por la red o almacenarlos. La validación sustenta ambas: no puedes formatear ni minificar de forma fiable un texto que para empezar no es JSON válido.

Cuándo formatear frente a minificar

Recurre a formatear siempre que una persona necesite mirar los datos:

• Inspeccionar la respuesta de una API mientras depuras.
• Revisar o editar un package.json, un tsconfig.json o cualquier archivo de configuración.
• Comparar dos archivos JSON en el control de versiones, donde una sangría coherente mantiene la diferencia pequeña y significativa.
• Pegar un bloque denso de una sola línea sacado de un registro y querer entender de verdad su forma.

Recurre a minificar cuando importan los bytes y nadie lo va a leer:

• Enviar JSON en el cuerpo de una respuesta o solicitud HTTP, donde las cargas útiles más pequeñas implican transferencias más rápidas.
• Incrustar configuración en una variable de entorno o en una URL.
• Almacenar muchos registros donde los espacios en blanco se acumulan a lo largo de miles de filas.

Un hábito útil: mantén tus archivos de origen formateados para que sean legibles, y deja que tu proceso de compilación o tu servidor minifiquen al salir. Obtienes lo mejor de ambos mundos: legible en el repositorio, compacto en la red.

Los errores de JSON más comunes (y cómo corregirlos)

JSON es deliberadamente estricto, que es lo que lo hace portable entre todos los lenguajes. Esa misma rigidez hace tropezar a la gente, sobre todo a quien está acostumbrado a escribir literales de objetos de JavaScript. Estos son los errores que aparecen una y otra vez:

• Comas finales. Una coma después del último elemento de un objeto o un arreglo —{"a": 1,}— es inválida. Elimínala. Es el error más común, porque la mayoría de los lenguajes de programación lo permiten.
• Comillas simples en lugar de comillas dobles. JSON requiere comillas dobles tanto para las claves como para los valores de cadena. {'name': 'Ada'} debe convertirse en {"name": "Ada"}.
• Claves sin comillas. Las claves son siempre cadenas entre comillas. {name: "Ada"} es un objeto de JavaScript, no JSON; debe ser {"name": "Ada"}.
• Comas que faltan. Cada elemento, excepto el último, necesita una coma que lo separe del siguiente. Dos valores seguidos sin nada entre medias no se podrán analizar.
• Comentarios. JSON no tiene sintaxis para comentarios. Las líneas que empiezan por // o envueltas en /* */ no están permitidas y deben eliminarse antes de que el texto se valide.

Algunos más a los que prestar atención: los números no pueden tener ceros a la izquierda ni un punto decimal final, las cadenas deben escapar caracteres especiales como \n y \", y los únicos literales permitidos además de números y cadenas son true, false y null (en minúsculas y sin comillas).

Cómo leer un error de análisis

Cuando la validación falla, el analizador normalmente informa de una posición: una línea y una columna, o un desplazamiento de caracteres. Lee esa ubicación de forma literal: el error se reporta en el primer carácter que el analizador no pudo interpretar, que a menudo está justo después del error real. Por ejemplo, una coma que falta suele señalarse al comienzo de la siguiente clave, no en el hueco donde debería haber estado la coma. Salta al punto indicado y luego mira el token inmediatamente anterior. Una vez que corrijas el primer error, vuelve a validar, porque un analizador se detiene en el primer problema y puede haber más por detrás.

Hazlo de forma privada en tu navegador

Muchas herramientas de JSON en línea envían lo que pegas a un servidor remoto para procesarlo. Con JSON, eso suele ser lo peor que puedes subir, porque es exactamente donde tienden a vivir las claves de API, los tokens de acceso, los nombres de host internos, los registros de clientes y otros secretos.

El formateador de JSON de Andev evita eso por completo. Usa los propios JSON.parse y JSON.stringify nativos del navegador, lo que significa:

• Tus datos nunca se suben. Todo se ejecuta de forma local en tu dispositivo; no se envía nada a ninguna parte.
• Muestra el error de análisis exacto. Cuando la entrada no es válida, ves el mensaje y la ubicación específicos para ir directo al problema.
• Eliges el tamaño de sangría. Formatea con dos espacios, cuatro espacios o tabulaciones para que coincida con el estilo de tu proyecto, o minifica en una sola línea.
• Es instantáneo. Sin viajes de ida y vuelta de subir y esperar; el resultado aparece tan rápido como puedas pegar.

Como se apoya en el mismo motor de JSON que tus aplicaciones ya usan, la validación que informa coincide con cómo se comportará realmente tu código cuando analice la misma cadena. Eso lo hace seguro para usar con configuraciones y cargas útiles de API sensibles, y fiable como comprobación rápida antes de publicar.

Para tareas vecinas, el mismo enfoque local y sin subidas impulsa el codificador y decodificador Base64 de Andev y su codificador y decodificador de URL, ambos prácticos cuando el JSON se incrusta en un URI de datos, un token o una cadena de consulta.

Conclusiones clave

• Formatear añade sangría para la legibilidad; minificar elimina los espacios en blanco para cargas útiles más pequeñas; validar comprueba la sintaxis. Son tres tareas distintas.
• Formatea para las personas, minifica para la red: mantén los archivos de origen legibles y deja que tu proceso de compilación compacte la salida.
• La mayoría de los errores son trampas de la rigidez: las comas finales, las comillas simples, las claves sin comillas, las comas que faltan y los comentarios son todos JSON inválido.
• Lee los errores de análisis en la posición indicada y luego comprueba el token justo anterior; corrige un error y vuelve a validar, ya que el analizador se detiene en el primero.
• Mantenlo local. Un formateador nativo del navegador nunca sube tus datos, lo que importa sobre todo para los secretos que viven dentro del JSON de configuración y de API.

¿Necesitas limpiar o comprobar algo de JSON ahora mismo? Abre el formateador de JSON gratuito y privado, sin subidas y sin registro, o explora el conjunto completo de herramientas para desarrolladores dentro del navegador.