Por qué comparar archivos JSON es más difícil de lo que parece
A primera vista, comparar dos archivos JSON parece simple. Solo hay que mirarlos uno al lado del otro y detectar las diferencias. Pero JSON tiene propiedades que hacen que la comparación visual no sea fiable.
Considera estos dos objetos JSON:
{"name":"Alice","age":30,"city":"Paris"}
{"city":"Paris","name":"Alice","age":30}
Son idénticos en significado. Las claves de un objeto JSON no tienen un orden definido. Pero si los comparas como texto (como usando diff en una terminal), parecen completamente diferentes.
Ahora considera esto:
{"score": 100}
{"score": "100"}
Parecen casi idénticos pero son fundamentalmente diferentes. El primero tiene un número, el segundo una cadena de texto. Una comparación textual podría no detectar esto. Una comparación JSON adecuada sí lo hará.
Por eso necesitas una herramienta que entienda la estructura JSON, no solo texto.
Tipos de diferencias en JSON
Al comparar dos objetos JSON, las diferencias se clasifican en estas categorías:
1. Claves añadidas
Una clave existe en el segundo JSON pero no en el primero:
// Antes
{ "name": "Alice" }
// Después
{ "name": "Alice", "email": "alice@example.com" }
Diferencia: email fue añadido.
2. Claves eliminadas
Una clave existe en el primer JSON pero no en el segundo:
// Antes
{ "name": "Alice", "age": 30 }
// Después
{ "name": "Alice" }
Diferencia: age fue eliminado.
3. Valores modificados
La misma clave existe en ambos pero con valores diferentes:
// Antes
{ "name": "Alice", "city": "Paris" }
// Después
{ "name": "Alice", "city": "London" }
Diferencia: city cambió de "Paris" a "London".
4. Cambios de tipo
La misma clave existe con el mismo valor aparente pero de tipos diferentes:
// Antes
{ "active": true }
// Después
{ "active": "true" }
Diferencia: active pasó del booleano true a la cadena "true". Es una diferencia sutil pero crítica que rompe muchas aplicaciones.
5. Diferencias anidadas
Cambios profundamente enterrados en objetos anidados:
// Antes
{
"user": {
"address": {
"city": "Paris",
"zip": "75001"
}
}
}
// Después
{
"user": {
"address": {
"city": "Lyon",
"zip": "69001"
}
}
}
Una buena herramienta de diff JSON muestra exactamente dónde en la estructura anidada ocurrió el cambio.
6. Diferencias en arrays
Los arrays están ordenados en JSON, por lo que la posición de los elementos importa:
// Antes
{ "tags": ["javascript", "python", "go"] }
// Después
{ "tags": ["javascript", "go", "python"] }
Son diferentes porque el orden cambió. Si esto importa o no depende de tu aplicación, pero una herramienta de diff JSON debería señalarlo.
Errores comunes de comparación
Error 1: Comparar JSON formateado vs minificado
// Archivo A (formateado)
{
"name": "Alice",
"age": 30
}
// Archivo B (minificado)
{"name":"Alice","age":30}
Son JSON idénticos pero parecen completamente diferentes como texto. Una herramienta de diff textual mostrará cada línea como modificada. Una herramienta de diff JSON no mostrará diferencias.
Error 2: Comparar con diferentes órdenes de claves
// Archivo A
{ "name": "Alice", "age": 30 }
// Archivo B
{ "age": 30, "name": "Alice" }
JSON idéntico. El diff textual muestra diferencias. El diff JSON no muestra ninguna.
Error 3: Ignorar diferencias de espaciado
Espacios extra, tabulaciones o saltos de línea pueden hacer que las comparaciones textuales sean ruidosas sin representar cambios reales en los datos.
Error 4: No detectar diferencias de tipos
{ "count": 0 }
{ "count": null }
{ "count": false }
{ "count": "0" }
{ "count": "" }
Los cinco son valores completamente diferentes en JSON. Una comparación textual podría no hacer clara la distinción. Una comparación JSON adecuada debe distinguir entre números, null, booleanos y cadenas.
Comparar JSON en JavaScript
Una comparación profunda simple:
function jsonEqual(a, b) {
return JSON.stringify(sortKeys(a)) === JSON.stringify(sortKeys(b));
}
function sortKeys(obj) {
if (typeof obj !== 'object' || obj === null) return obj;
if (Array.isArray(obj)) return obj.map(sortKeys);
return Object.keys(obj).sort().reduce((acc, key) => {
acc[key] = sortKeys(obj[key]);
return acc;
}, {});
}
Esto normaliza el orden de las claves antes de comparar. Funciona para verificaciones de igualdad pero no te dice qué cambió.
Para un diff detallado, necesitas recorrer ambos objetos recursivamente y rastrear adiciones, eliminaciones y cambios en cada nivel.
Comparar JSON en Python
import json
with open('before.json') as f:
before = json.load(f)
with open('after.json') as f:
after = json.load(f)
# Verificación simple de igualdad
if before == after:
print("Idéntico")
else:
print("Diferente")
El operador == de Python realiza una comparación profunda de diccionarios y listas, incluyendo verificación de tipos. Esto maneja correctamente los objetos anidados pero no te muestra dónde están las diferencias.
Para diffs detallados, usa la biblioteca deepdiff:
from deepdiff import DeepDiff
diff = DeepDiff(before, after, ignore_order=True)
print(diff)
Cuándo importa la comparación JSON
Pruebas de respuesta de API
Al probar APIs, comparas las respuestas esperadas con las reales. Una herramienta de diff JSON muestra exactamente qué campos cambiaron, haciendo que las fallas en las pruebas sean fáciles de diagnosticar.
Gestión de configuración
Al desplegar cambios de configuración, comparar los archivos de configuración JSON antiguos y nuevos previene eliminaciones o modificaciones accidentales.
Verificación de migración de base de datos
Después de migrar datos, comparar las exportaciones JSON de las bases de datos antigua y nueva confirma que no se perdieron ni corrompieron datos.
Revisión de código
Cuando una pull request modifica un archivo de configuración JSON, un diff adecuado muestra los cambios estructurales reales en lugar de diferencias ruidosas de espaciado.
Depuración
Cuando una API de repente devuelve datos diferentes, comparar la respuesta actual con una respuesta conocida como correcta identifica exactamente qué cambió.
Comparar archivos JSON de forma segura
Cuando comparas archivos JSON que contienen datos sensibles (respuestas de API con datos de usuarios, archivos de configuración con secretos, exportaciones de base de datos), ten cuidado con dónde se realiza la comparación.
Las herramientas de diff JSON en línea procesan tus datos en sus servidores. Ambos archivos JSON se suben, se comparan del lado del servidor, y el resultado se devuelve. Tus datos han sido transmitidos y procesados por un tercero.
Si tu JSON contiene información sensible — registros de usuarios, configuración interna, claves API, datos de negocio — usa una herramienta de diff que se ejecute completamente en tu navegador. Ningún dato debería salir de tu máquina.
La herramienta FmtDev JSON Diff procesa todo localmente. Tus datos nunca salen de tu navegador.
Puntos clave
- El orden de las claves JSON no importa — las herramientas de diff textual dan falsos positivos
- Las diferencias de tipos (número vs cadena) son críticas pero fáciles de pasar por alto visualmente
- Siempre usa una herramienta de comparación compatible con JSON, no diff de texto simple
- Normaliza el formato antes de comparar para eliminar el ruido
- El orden de los arrays importa en JSON — los cambios de posición de elementos son diferencias reales
- Para datos sensibles, compara localmente — nunca subas a herramientas en línea