Comparateur de différences JSON
Comparez deux documents JSON et voyez instantanément quelles clés ont été ajoutées, supprimées ou modifiées, listées par chemin de clé. Les objets et tableaux sont parcourus récursivement, et même les incohérences de type sont signalées comme des changements. Tout se traite dans votre navigateur, sans envoi vers un serveur.
Qu'est-ce qu'un comparateur de différences JSON
Un comparateur de différences JSON confronte deux documents JSON structure par structure et montre instantanément quelles clés ont été ajoutées, lesquelles ont été supprimées et quelles valeurs ont changé. Il se révèle particulièrement utile lorsque la lecture du texte complet côte à côte n'est plus praticable en raison de la quantité d'informations : une réponse d'API dont la forme a changé entre deux versions, ou un fichier de configuration qui diffère d'un environnement à l'autre. Cet outil parcourt les objets et les tableaux de manière récursive et signale les différences au niveau du chemin de clé, ce qui permet de localiser précisément où une valeur a changé, même au sein d'un JSON profondément imbriqué.
Pour que la comparaison fonctionne, les deux documents doivent être du JSON structurellement valide. Si l'une des entrées comporte une erreur de syntaxe — une virgule manquante, un guillemet non fermé, etc. — l'outil indique laquelle, de A ou de B, est invalide, plutôt que de tenter de calculer une différence. Il est également utile de comprendre les deux règles d'appariement distinctes appliquées par cet outil : les clés des objets sont associées par leur nom, tandis que les éléments des tableaux sont associés par leur index (leur ordre d'apparition). Garder ce principe à l'esprit aide à comprendre pourquoi une clé donnée est signalée comme « modifiée » plutôt que « ajoutée » ou « supprimée ».
Comment comparer du JSON avec le comparateur de différences JSON
- Collez le JSON source (A) Collez ou saisissez le texte JSON dans le premier champ. Vous pouvez copier un fichier de configuration ou une réponse d'API existante tel quel, sans aucun reformatage.
- Collez le JSON cible (B) Collez la version « après », ou le JSON d'un environnement différent, dans le second champ. Le document que vous placez en A et celui placé en B déterminent le sens indiqué pour les clés « ajoutées » et « supprimées ».
- Essayez les données d'exemple (facultatif) Cliquez sur « Charger un exemple » pour remplir les deux champs avec un exemple incluant des ajouts, des suppressions et des modifications, afin de voir immédiatement le format du résultat.
- Lisez les résultats de la différence Les clés supprimées, ajoutées et modifiées sont listées avec leur chemin de clé. Pour les clés modifiées, les valeurs avant et après sont affichées côte à côte afin de repérer la différence en un coup d'œil.
- Effacez les champs si nécessaire Utilisez le bouton « Effacer » pour vider les deux champs et commencer la comparaison d'une nouvelle paire de documents JSON.
Astuces pour en tirer le meilleur parti
- Les chemins de clé s'affichent en notation point/crochet, comme `user.address[0].city`, ce qui permet de repérer immédiatement quelle valeur imbriquée a changé, quelle que soit la profondeur de la structure JSON.
- Les tableaux sont comparés en associant les éléments au même index. Notez qu'un simple réordonnancement des éléments d'un tableau sera détecté comme un changement pour tous les éléments.
- Si une même clé contient une chaîne dans un document et un objet dans l'autre, cette incohérence de type est également signalée comme un changement, avec les deux valeurs brutes affichées côte à côte.
- Lorsque vous comparez des réponses d'API avant et après un déploiement, retirez d'abord les champs qui changent systématiquement, comme les horodatages ou les identifiants de requête, afin de vous concentrer uniquement sur les différences qui comptent vraiment.
- Même pour un JSON contenant énormément de valeurs inchangées, seul le nombre de valeurs feuilles identiques est affiché, ce qui garde le résultat lisible plutôt que surchargé.
Cas d'usage
Détecter des changements involontaires dans les réponses d'API
Enregistrez une réponse d'API avant et après un déploiement du backend, puis comparez-les ici pour détecter tôt des ajouts, suppressions ou changements de type involontaires, avant qu'ils n'atteignent les utilisateurs en production.
Comparer des fichiers de configuration entre environnements
Comparez le config.json ou le package.json de préproduction et de production pour repérer des variables d'environnement manquantes ou des divergences de version qui passeraient autrement inaperçues.
Expliquer une différence lors d'une revue de code
Lors de la revue d'une charge utile de migration ou d'une définition de schéma au format JSON, partagez directement la liste des différences générée plutôt que de décrire les changements verbalement ou dans un long fil de commentaires.
Déboguer des tests de snapshot en échec
Comparez un instantané (snapshot) JSON produit par un test automatisé à la valeur attendue pour identifier rapidement quel champ précis a causé l'échec du test.
Valider les charges utiles de webhooks tiers
Comparez une charge utile réellement reçue d'un webhook à un exemple documenté pour confirmer qu'elle correspond bien à la structure décrite dans la spécification de l'API.
Glossaire
- Chemin de clé
- Une chaîne représentant le trajet depuis la racine d'un document JSON jusqu'à une valeur précise, écrite en notation point/crochet comme `user.address[0].city`. Les résultats de différence sont regroupés et affichés à ce niveau.
- Imbrication
- Une structure dans laquelle un objet ou un tableau contient à son tour d'autres objets ou tableaux. Plus l'imbrication est profonde, plus il devient difficile de repérer les changements à l'œil seul.
- Valeur feuille
- Une valeur terminale dans un arbre JSON qui ne se ramifie plus — une chaîne, un nombre, un booléen ou null. Une comparaison de différences revient finalement à apparier des valeurs feuilles entre elles.
- Incohérence de type
- Une situation où la valeur au même chemin de clé est d'un type de donnée (par exemple une chaîne) dans un document et d'un type différent (par exemple un objet) dans l'autre. Cet outil signale également les incohérences de type comme des changements.
- Erreur de syntaxe
- Un texte mal formé qui provoque l'échec de JSON.parse. Une virgule manquante ou un guillemet non fermé en sont des exemples typiques.
- JSONPath
- Une spécification de langage de requête permettant d'adresser des valeurs au sein d'un document JSON. La notation de chemin de clé utilisée dans cet outil est, conceptuellement, une version simplifiée apparentée à la syntaxe JSONPath.
Questions fréquentes
Anecdote — En quoi l'appariement des clés diffère entre le diff CSV et le diff JSON
Notre comparateur de différences CSV compare lignes et cellules en s'appuyant sur une seule colonne clé désignée pour identifier chaque ligne. Le JSON ne possède pas de structure plate en lignes et colonnes — il autorise l'imbrication d'objets et de tableaux — donc, bien que les deux outils portent le nom de « comparateur de différences », l'algorithme d'appariement sous-jacent est assez différent. Au lieu d'une colonne clé, cet outil utilise un « chemin de clé » construit récursivement depuis la racine jusqu'à chaque feuille comme unité de comparaison.
Les tableaux constituent la partie la plus délicate lors de la comparaison de JSON. Une ligne CSV peut être identifiée de façon unique par la valeur de sa colonne clé, mais les éléments d'un tableau JSON ne possèdent aucun identifiant garanti. Cet outil associe simplement les éléments par index (ordre d'apparition), une conception mieux adaptée pour suivre les changements de structure d'un objet ou de valeurs primitives — comme dans des fichiers de configuration ou des réponses d'API — que pour suivre les ajouts et suppressions au sein du contenu d'un tableau.
En pratique, une idée similaire apparaît dans les pipelines d'intégration continue qui vérifient automatiquement si le contrat de réponse d'une API REST a changé. Cet outil privilégie la commodité de fonctionner entièrement dans le navigateur, mais le concept sous-jacent rejoint les tests de snapshot et les tests de contrat (contract testing) : détecter mécaniquement les différences de structure JSON est un défi récurrent à de nombreuses étapes du développement logiciel.