Pourquoi comparer des fichiers JSON est plus difficile qu'il n'y paraît
À première vue, comparer deux fichiers JSON semble simple. Il suffit de les regarder côte à côte et de repérer les différences. Mais JSON possède des propriétés qui rendent la comparaison visuelle peu fiable.
Considérez ces deux objets JSON :
{"name":"Alice","age":30,"city":"Paris"}
{"city":"Paris","name":"Alice","age":30}
Ils sont identiques en termes de signification. Les clés d'un objet JSON n'ont pas d'ordre défini. Mais si vous les comparez en tant que texte (comme avec diff dans un terminal), ils semblent complètement différents.
Maintenant considérez ceci :
{"score": 100}
{"score": "100"}
Ils semblent presque identiques mais sont fondamentalement différents. Le premier contient un nombre, le second une chaîne de caractères. Une comparaison textuelle pourrait manquer cela. Une comparaison JSON correcte le détectera.
C'est pourquoi vous avez besoin d'un outil qui comprend la structure JSON, pas simplement le texte.
Types de différences JSON
Lors de la comparaison de deux objets JSON, les différences se répartissent en ces catégories :
1. Clés ajoutées
Une clé existe dans le second JSON mais pas dans le premier :
// Avant
{ "name": "Alice" }
// Après
{ "name": "Alice", "email": "alice@example.com" }
Différence : email a été ajouté.
2. Clés supprimées
Une clé existe dans le premier JSON mais pas dans le second :
// Avant
{ "name": "Alice", "age": 30 }
// Après
{ "name": "Alice" }
Différence : age a été supprimé.
3. Valeurs modifiées
La même clé existe dans les deux mais avec des valeurs différentes :
// Avant
{ "name": "Alice", "city": "Paris" }
// Après
{ "name": "Alice", "city": "London" }
Différence : city a changé de "Paris" à "London".
4. Changements de type
La même clé existe avec la même valeur apparente mais de types différents :
// Avant
{ "active": true }
// Après
{ "active": "true" }
Différence : active est passé du booléen true à la chaîne "true". C'est une différence subtile mais critique qui casse de nombreuses applications.
5. Différences imbriquées
Des changements profondément enfouis dans des objets imbriqués :
// Avant
{
"user": {
"address": {
"city": "Paris",
"zip": "75001"
}
}
}
// Après
{
"user": {
"address": {
"city": "Lyon",
"zip": "69001"
}
}
}
Un bon outil de diff JSON montre exactement où dans la structure imbriquée le changement s'est produit.
6. Différences de tableaux
Les tableaux sont ordonnés en JSON, donc la position des éléments compte :
// Avant
{ "tags": ["javascript", "python", "go"] }
// Après
{ "tags": ["javascript", "go", "python"] }
Ils sont différents car l'ordre a changé. Que cela compte ou non dépend de votre application, mais un outil de diff JSON devrait le signaler.
Erreurs courantes de comparaison
Erreur 1 : Comparer du JSON formaté vs minifié
// Fichier A (formaté)
{
"name": "Alice",
"age": 30
}
// Fichier B (minifié)
{"name":"Alice","age":30}
Ce sont des JSON identiques mais ils semblent complètement différents en tant que texte. Un outil de diff textuel montrera chaque ligne comme modifiée. Un outil de diff JSON ne montrera aucune différence.
Erreur 2 : Comparer avec des ordres de clés différents
// Fichier A
{ "name": "Alice", "age": 30 }
// Fichier B
{ "age": 30, "name": "Alice" }
JSON identique. Le diff textuel montre des différences. Le diff JSON n'en montre aucune.
Erreur 3 : Ignorer les différences d'espacement
Des espaces supplémentaires, des tabulations ou des retours à la ligne peuvent rendre les comparaisons textuelles bruyantes sans représenter de vrais changements de données.
Erreur 4 : Manquer les différences de types
{ "count": 0 }
{ "count": null }
{ "count": false }
{ "count": "0" }
{ "count": "" }
Les cinq sont des valeurs complètement différentes en JSON. Une comparaison textuelle pourrait ne pas rendre la distinction claire. Une comparaison JSON correcte doit distinguer entre nombres, null, booléens et chaînes.
Comparer du JSON en JavaScript
Une comparaison profonde 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;
}, {});
}
Cela normalise l'ordre des clés avant la comparaison. Cela fonctionne pour les vérifications d'égalité mais ne vous dit pas ce qui a changé.
Pour un diff détaillé, vous devez parcourir les deux objets récursivement et suivre les ajouts, suppressions et modifications à chaque niveau.
Comparer du 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)
# Vérification simple d'égalité
if before == after:
print("Identique")
else:
print("Différent")
L'opérateur == de Python effectue une comparaison profonde des dictionnaires et des listes, incluant la vérification des types. Cela gère correctement les objets imbriqués mais ne vous montre pas où se trouvent les différences.
Pour des diffs détaillés, utilisez la bibliothèque deepdiff :
from deepdiff import DeepDiff
diff = DeepDiff(before, after, ignore_order=True)
print(diff)
Quand la comparaison JSON est importante
Tests de réponse API
Lors des tests d'APIs, vous comparez les réponses attendues aux réponses réelles. Un outil de diff JSON montre exactement quels champs ont changé, rendant les échecs de tests faciles à diagnostiquer.
Gestion de configuration
Lors du déploiement de changements de configuration, comparer les anciens et nouveaux fichiers de configuration JSON empêche les suppressions ou modifications accidentelles.
Vérification de migration de base de données
Après une migration de données, comparer les exports JSON des anciennes et nouvelles bases de données confirme qu'aucune donnée n'a été perdue ou corrompue.
Revue de code
Quand une pull request modifie un fichier de configuration JSON, un diff approprié montre les vrais changements structurels au lieu de différences d'espacement bruyantes.
Débogage
Quand une API retourne soudainement des données différentes, comparer la réponse actuelle avec une réponse connue comme correcte identifie exactement ce qui a changé.
Comparer des fichiers JSON en toute sécurité
Lorsque vous comparez des fichiers JSON contenant des données sensibles (réponses API avec des données utilisateur, fichiers de configuration avec des secrets, exports de base de données), faites attention à l'endroit où la comparaison se fait.
Les outils de diff JSON en ligne traitent vos données sur leurs serveurs. Les deux fichiers JSON sont téléchargés, comparés côté serveur, et le résultat est renvoyé. Vos données ont été transmises et traitées par un tiers.
Si votre JSON contient des informations sensibles — données utilisateur, configuration interne, clés API, données métier — utilisez un outil de diff qui s'exécute entièrement dans votre navigateur. Aucune donnée ne devrait quitter votre machine.
L'outil FmtDev JSON Diff traite tout localement. Vos données ne quittent jamais votre navigateur.
Points clés à retenir
- L'ordre des clés JSON ne compte pas — les outils de diff textuel donnent des faux positifs
- Les différences de types (nombre vs chaîne) sont critiques mais faciles à manquer visuellement
- Utilisez toujours un outil de comparaison compatible JSON, pas un diff textuel simple
- Normalisez le formatage avant de comparer pour éliminer le bruit
- L'ordre des tableaux compte en JSON — les changements de position des éléments sont de vraies différences
- Pour les données sensibles, comparez localement — ne téléchargez jamais vers des outils en ligne