Formatea o minifica JSON y valídalo según RFC 8259, con explicaciones claras de los errores de sintaxis y su línea y columna.
Por AdminRedactado con herramientas de redacción con IAActualizado Ejemplos verificados: 6
El JSON es válido. Valores: 10; claves: 6; profundidad de anidamiento: 2. El formato con sangría cambia el tamaño de 127 a 170 bytes.
{
"name": "CalcOpenly",
"version": "1.0.0",
"precision": 50,
"domains": [
"math",
"finance",
"programming"
],
"offline": true,
"license": null
}| Tipo | Cantidad |
|---|---|
| Objetos | 1 |
| Arrays | 1 |
| Cadenas | 5 |
| Números | 1 |
| Booleanos | 1 |
| Valores null | 1 |
JSON válido: Objetos: 1, Arrays: 1, Cadenas: 5, Números: 1, Booleanos: 1, Valores null: 1.
Claves en total: 6; nivel de anidamiento más profundo: 2.
Un miembro o elemento por línea, con 2 espacios de sangría por nivel.
Las cadenas y los números se copian exactamente como están escritos, sin cambiar escapes ni formatos numéricos.
El validador analiza el texto con la gramática RFC 8259: objetos, arrays, cadenas entre comillas dobles, números, true, false y null, sin otros elementos. Si el análisis tiene éxito, vuelve a escribir los mismos valores, con un miembro por línea y 2 espacios, 4 espacios o un tabulador por nivel, o minificados, sin espacios fuera de las cadenas. Si falla, indica la línea y columna donde se incumple la gramática y qué esperaba encontrar.
Sirve para leer respuestas de API y archivos de configuración, y reducir el tamaño de los datos enviados. El objeto inicial tiene 6 claves y 10 valores, con 2 niveles de anidación. Al formatearlo con 2 espacios pasa de 127 a 170 bytes.
Las cadenas y los números se copian exactamente como están escritos: se conservan los escapes y todas las cifras de un entero grande como 12345678901234567890123.
El formateador y validador de JSON comprueba la sintaxis, distribuye un documento válido en líneas legibles o elimina los espacios que sobran para obtener una representación compacta. Selecciona el modo, la sangría y, si lo necesitas, la ordenación de las claves. El resultado aparece junto a las cuentas de claves, valores, niveles de anidamiento y bytes UTF-8.
El documento inicial contiene seis claves, diez valores y dos niveles de profundidad. Su representación compacta ocupa 127 bytes UTF-8; el formato inicial con dos espacios de sangría ocupa 170 bytes. La diferencia procede de los espacios y saltos de línea añadidos. No significa que los valores hayan aumentado de tamaño ni que el documento contenga información nueva.
Utiliza el resultado para revisar una configuración, comparar respuestas de una API o localizar un error. La validación confirma que el texto cumple la gramática admitida por la herramienta. Para saber si una API acepta esos campos, hace falta comprobar también el contrato de esa API y el significado de cada valor.
RFC 8259 describe la sintaxis de intercambio JSON. Las cadenas y los nombres de propiedades llevan comillas dobles. Los miembros de un objeto se separan mediante comas, y cada nombre se une a su valor mediante dos puntos. Los corchetes delimitan listas de valores.
Una coma después del último miembro, las comillas simples, los comentarios y los nombres sin comillas son causas habituales de error. Expresiones válidas en ciertos contextos de JavaScript, como NaN, Infinity, 0x10 o +1, no son números JSON. Varios documentos pegados uno detrás de otro tampoco forman automáticamente un único documento válido.
Cuando aparezca una línea y una columna de error, revisa esa posición y el delimitador anterior. Una comilla o un corchete que falta puede hacer que el problema se detecte más adelante. Corrige el texto y vuelve a validarlo; la primera posición indicada no enumera necesariamente todos los errores presentes.
El valor raíz puede ser un objeto, un array, una cadena, un número, un booleano o null. Por ejemplo, 42 es una entrada válida. Que un servicio concreto exija un objeto en la raíz es una condición adicional de ese servicio.
La cuenta Valores incluye los propios objetos y arrays, además de sus cadenas, números, booleanos y valores nulos. Los nombres de las propiedades se cuentan como claves; no se añaden a la fila de cadenas. Las propiedades repetidas se cuentan tal como aparecen en el documento.
En el ejemplo inicial hay un objeto, un array, cinco cadenas de valor, un número, un booleano y un nulo. La suma es diez. Los tres nombres incluidos dentro del array de dominios son cadenas, mientras que los nombres de las propiedades exteriores pertenecen a la cuenta de claves.
La profundidad mide contenedores anidados. Una raíz escalar tiene profundidad cero; un objeto que solo contiene escalares tiene profundidad uno. El array incluido en el objeto inicial añade el segundo nivel. Esta medida describe la estructura, pero por sí sola no determina la dificultad de comprender el contenido.
La tabla de tipos desglosa esas cantidades. Su descarga CSV contiene estadísticas del documento. Para trasladar el JSON formateado a otro programa, copia el resultado de texto correspondiente; el CSV de cuentas no contiene una copia equivalente de los datos originales.
El formateador conserva la escritura de los números y los escapes de las cadenas. El identificador 123456789012345678901234567890 mantiene sus treinta dígitos. También se conservan representaciones como 1.2300, -0 o 1E-999, aunque otro serializador pudiera elegir una escritura diferente del mismo valor.
El aviso sobre números largos señala un problema posible de interoperabilidad. Esta herramienta puede conservar un token que otra aplicación redondee al convertirlo a coma flotante. Cuando el contrato receptor lo permite, los identificadores grandes pueden representarse como cadenas. Añadir sangría no evita una pérdida de precisión posterior.
Una letra escapada y la misma letra escrita directamente pueden representar el mismo carácter y conservar apariencias diferentes en el resultado. Ordenar las claves tampoco normaliza esas decisiones. Un salto de línea escapado dentro de una cadena sigue siendo una secuencia de escape y no se convierte en un salto literal que invalidaría esa cadena.
Para inspeccionar bytes o representaciones de texto, utiliza el codificador y decodificador. Identifica primero la capa que quieres transformar: interpretar un escape JSON y decodificar un contenido Base64 son operaciones diferentes.
Un objeto con nombres repetidos se acepta con un aviso. El resultado conserva ambos miembros: {"a":1,"a":2} no se reduce silenciosamente a un objeto con un solo valor. El aviso identifica la ubicación del objeto que contiene la repetición.
Distintos receptores pueden tratar esos nombres de manera diferente. Decide qué propiedad debe permanecer según el modelo de datos antes de compartir el documento. El formateador no puede determinar si se pretendía conservar el primer valor, el último o una colección de ambos.
La ordenación compara los nombres decodificados por puntos de código Unicode, incluidos los caracteres suplementarios. Se aplica a cada objeto y conserva el orden relativo de nombres iguales. No reordena arrays, no interpreta fechas y no utiliza una ordenación alfabética específica del español.
| Escenario | Claves | Profundidad | Valores | Bytes de salida |
|---|---|---|---|---|
| Predeterminado | 6 | 2 | 10 | 170 |
| Predeterminado compactado | 6 | 2 | 10 | 127 |
| Número raíz | 0 | 0 | 1 | 2 |
| Claves duplicadas | 5 | 2 | 6 | 64 |
| Entero grande exacto | 1 | 1 | 2 | 42 |
La fila de duplicados utiliza {"a":1,"a":2,"nested":{"a":3,"a":4}} con ordenación activada. La del entero grande coloca el identificador de treinta dígitos bajo la clave id. Salvo la fila compactada, los ejemplos emplean dos espacios de sangría.
El tamaño se mide en bytes UTF-8. Un carácter visible puede ocupar varios bytes, y los espacios dentro de una cadena conservan su significado al compactar. La entrada admite hasta 200000 unidades UTF-16 y rechaza un anidamiento excesivo. Para reproducir un resumen con la calculadora hash, conserva exactamente la representación requerida: sangría, orden y saltos finales modifican los bytes.
Fuente de comprobación: Cálculo independiente
Fuente de comprobación: len = 45, salida de 33 bytes
Fuente de comprobación: Comprobación del ejemplo: RFC 8259 §2 (cualquier valor puede ser el texto raíz)
Fuente de comprobación: Cálculo independiente
Las comas finales, las comillas simples y las claves sin comillas causan la mayoría de los errores. JSON exige comillas dobles para cada cadena y clave, y no permite una coma tras el último elemento. Los comentarios, NaN, Infinity y los números hexadecimales tampoco son válidos según RFC 8259, aunque JavaScript admita algunos en su código. El mensaje indica línea y columna para localizar el carácter que impidió el análisis.
No. RFC 8259 y ECMA-404 no definen sintaxis de comentarios, así que un analizador estándar rechaza // y /* */. Douglas Crockford retiró los comentarios del formato en sus inicios porque se usaban para incluir instrucciones para el analizador. Los archivos de configuración que necesitan comentarios usan JSON5 o JSONC, como settings.json de VS Code; este validador los identifica como JSON no válido.
RFC 8259 no fija un límite, pero advierte de que solo los enteros entre −(2^53 − 1) y 2^53 − 1 = 9 007 199 254 740 991 garantizan interoperabilidad, porque muchos analizadores usan dobles IEEE 754. Esta herramienta copia los números cifra a cifra, pero JSON.parse de JavaScript transforma 12345678901234567890123 en 1.2345678901234568e22. Por eso conviene transmitir identificadores grandes como cadenas.
RFC 8259 recomienda que los nombres de un objeto sean únicos (SHOULD). Los duplicados son sintácticamente válidos, pero poco fiables: JSON.parse de JavaScript y el módulo json de Python conservan solo el último valor, mientras que otros analizadores conservan el primero o rechazan el documento. Este validador los acepta, pero avisa con la línea y columna del objeto para que puedas corregirlos antes de que otro sistema los interprete de forma distinta.
Formatear coloca cada miembro en su propia línea con 2 o 4 espacios o un tabulador por nivel, lo que facilita leerlo y comparar cambios. Minificar elimina los espacios y saltos de línea fuera de las cadenas para transmitirlo. Ambos representan exactamente los mismos datos. El ejemplo inicial pasa de 127 a 170 bytes al formatearse, y el ejemplo de minificación baja de 45 a 33 bytes.
Esta calculadora incluye 6 ejemplos resueltos con respuestas de fuentes independientes. Forman parte del conjunto de pruebas y también puedes ejecutarlos aquí.