Porównaj dwie struktury JSON

Panel
Dokumentacja
API

porównaj dwie struktury JSON i wypisz dodania, usunięcia i modyfikacje, klucz po kluczu

Pourquoi comparer deux JSON ?

Comparer deux structures JSON revient régulièrement dans la vie d'un développeur. Une réponse d'API qui change après une mise à jour. Un fichier de configuration qui diverge entre deux environnements. Une export d'objets qui doit s'aligner sur une référence. Un diff JSON répond précisément à cette question : qu'est-ce qui a été ajouté, supprimé ou modifié, et à quel endroit ?

Un diff ligne à ligne (à la git diff) ne suffit souvent pas. Si le formatage diffère (espaces, ordre des clés), le diff textuel signale des centaines de lignes alors que la structure de données est identique. Un comparateur JSON travaille sur la structure une fois parsée, ce qui élimine ce bruit et révèle uniquement les écarts sémantiques.

Le format du diff produit par l'outil

Pour chaque écart, l'outil retourne :

un chemin au format JSONPath simplifié, par exemple $.user.address[0].city ;
un type parmi added (ajouté à droite), removed (présent à gauche seulement), modified (valeurs différentes) ;
la valeur de gauche et/ou la valeur de droite selon le type.

Un diff vide signifie que les deux JSON sont structurellement identiques, indépendamment de leur formatage ou de l'ordre des clés.

Comment l'algorithme parcourt les deux structures

L'algorithme est récursif. À chaque niveau, il identifie le type des deux valeurs comparées :

Si les deux sont des objets associatifs, il prend l'union des clés. Pour chaque clé, il descend récursivement, ou marque added/removed si la clé n'existe que d'un côté.
Si les deux sont des tableaux ordonnés, il compare position par position. Une différence en début de tableau peut décaler tout le reste, ce qui produit un diff verbeux : c'est une limite assumée du diff structurel naïf.
Si les types diffèrent (objet face à tableau, scalaire face à null), c'est marqué modified.
Si les deux valeurs sont des scalaires (chaîne, nombre, booléen, null), une simple comparaison stricte suffit.

L'ordre des clés dans un objet ne compte pas : {"a": 1, "b": 2} et {"b": 2, "a": 1} produisent un diff vide. C'est conforme à la sémantique JSON, où l'ordre n'est pas significatif. En revanche, l'ordre des éléments d'un tableau compte : un tableau est ordonné par construction.

Un exemple concret

Voici deux versions d'un objet utilisateur :

// gauche
{
  "id": 42,
  "name": "Alice",
  "roles": ["admin", "editor"]
}

// droite
{
  "id": 42,
  "name": "Alice Martin",
  "roles": ["admin", "viewer"],
  "active": true
}

Le diff produit :

$.name: modified, "Alice" → "Alice Martin"
$.roles[1]: modified, "editor" → "viewer"
$.active: added, true

Cas d'usage

Diff d'environnements : comparer la sortie d'un endpoint en pré-production et en production. Très utile lors d'une migration ou d'un rafraîchissement de cache.
Audit de migration : comparer un export avant et après transformation pour vérifier qu'aucun champ n'a été perdu.
Régression d'API : avant et après une modification, comparer la réponse pour une requête identique. Un diff vide confirme la non-régression.
Synchronisation de configurations : comparer composer.json entre deux branches, deux fichiers .eslintrc, deux configurations Symfony.
Snapshot tests : remplacer une comparaison ligne à ligne par une comparaison structurelle dans une suite de tests d'intégration.

Limites du diff structurel

Comparer des tableaux ordonnés est une limite connue des diffs structurels naïfs. Si l'on insère un élément en début de tableau, toutes les positions suivantes sont décalées et le diff signale chaque écart comme une modification. Pour de tels cas, des algorithmes plus avancés existent (Myers, Patience, diff par clé naturelle), mais ils sortent du cadre d'un outil de comparaison généraliste.

Le diff ne dit pas non plus pourquoi un changement a eu lieu : c'est un constat. Pour analyser une régression, il faut croiser ce constat avec les commits, les déploiements et les paramètres de la requête.

JSON diff vs JSON Patch (RFC 6902)

Un format complémentaire est JSON Patch (RFC 6902). Il décrit, sous forme d'opérations (add, remove, replace, move, copy, test), comment transformer un document JSON en un autre. Là où notre diff est un constat (humain), JSON Patch est une recette (machine). Les deux représentations sont équivalentes pour les cas simples, et JSON Patch est utile pour des API RESTful qui acceptent des modifications partielles.

Questions fréquentes

Le diff dépend-il de l'ordre des clés ?

Non : pour un objet JSON, l'ordre n'est pas significatif. Le comparateur produit le même résultat que les clés soient triées ou non.

Comment gérer les tableaux dont l'ordre n'est pas important ?

L'outil considère par défaut les tableaux comme ordonnés (c'est la sémantique JSON). Si vous traitez des ensembles, triez les deux tableaux par une clé naturelle avant de comparer, ou utilisez un service de comparaison spécialisé qui prend en compte cette sémantique.

Quelle est la différence avec un diff Git ?

Git compare des lignes de texte. Si l'indentation ou l'ordre des clés diffère, le diff Git est très verbeux. Le diff JSON travaille sur la structure parsée et ne signale que les écarts de données.

Un JSON invalide est-il accepté ?

Non : si l'un des deux JSON ne parse pas, l'outil renvoie une erreur. Validez d'abord avec notre validateur JSON.

Przykładowe zapytanie

curl -X POST https://cdrn.fr/api/v1/tools/json-diff/execute \
  -H "Content-Type: application/json" \
  -d '{"left":"...","right":"..."}'

Schemat wejściowy

Pole	Typ	Wymagane	Domyślnie
`left`	text	✓	–
`right`	text	✓	–

Punkty końcowe

GET https://cdrn.fr/api/v1/tools - lista wszystkich dostępnych narzędzi
GET https://cdrn.fr/api/v1/tools/json-diff - zwraca schemat dla tego narzędzia
POST https://cdrn.fr/api/v1/tools/json-diff/execute - uruchamia to narzędzie z payloadem JSON