Outil de comparaison JSON – comparer les différences JSON en ligne

Un outil de comparaison JSON, souvent appelé outil de comparaison des différences JSON, compare deux valeurs JSON (JavaScript Object Notation) et indique ce qui a changé entre elles. Il répertorie chaque propriété ou élément de tableau ajouté, supprimé ou modifié, ainsi que son emplacement exact dans les données. Cette page explique le fonctionnement de l’outil de comparaison JSON de whiz.tools, avec des exemples détaillés fondés sur sa logique de comparaison réelle.

Qu’est-ce que la comparaison JSON ?

La comparaison JSON consiste à confronter deux documents JSON pour trouver leurs différences. Un document JSON est un bloc de texte composé d’objets (paires clé-valeur entre accolades), de tableaux (listes ordonnées entre crochets) et de valeurs primitives telles que des chaînes, des nombres, des booléens et null. Comparer visuellement deux documents devient lent et source d’erreurs dès qu’ils dépassent quelques lignes. Un outil de comparaison effectue donc automatiquement la mise en correspondance et met chaque changement en évidence.

Les développeurs utilisent ce type de comparaison pour vérifier des réponses d’API, suivre les changements dans des fichiers de configuration, s’assurer qu’une migration de données n’a pas entraîné de perte d’informations et examiner les modifications apportées aux fichiers JSON dans un système de gestion de versions.

Comment l’outil compare deux valeurs JSON

L’outil analyse les deux entrées avec un analyseur JSON standard, puis parcourt les deux valeurs obtenues ensemble, niveau par niveau. À chaque étape, il pose trois questions, dans cet ordre :

Les deux valeurs ont-elles des types différents (par exemple, l’une est un objet et l’autre un nombre), ou l’une est-elle null alors que l’autre ne l’est pas ? Si oui, il enregistre une modification à cet emplacement et arrête la comparaison plus approfondie.
Les deux valeurs sont-elles primitives (une chaîne, un nombre, un booléen ou null) ? Si oui, il les compare directement. Toute différence, y compris le passage du nombre 123 à la chaîne "123", compte comme une modification.
Les deux valeurs sont-elles des objets ou toutes deux des tableaux ? Si oui, il compare leur contenu selon les règles ci-dessous et recommence l’opération dans les objets ou tableaux imbriqués.

Chaque différence est enregistrée avec un chemin, tel que user.address.city ou tags[1], afin de pouvoir la retrouver facilement dans le document d’origine. Les membres d’un objet sont séparés par un point et les éléments d’un tableau sont indiqués avec leur indice entre crochets. Une différence située tout en haut du document, par exemple lorsqu’un tableau est remplacé par un objet, n’a pas de chemin à l’intérieur des données ; elle est donc désignée par $. Il s’agit de l’identifiant racine défini par la RFC 9535, la norme JSONPath, qui représente l’ensemble du document.

Comparaison des objets JSON

Pour deux objets JSON, l’outil rassemble toutes les clés qui apparaissent dans l’un ou l’autre objet. Pour chaque clé :

Si la clé existe uniquement dans le deuxième objet, il s’agit d’une propriété ajoutée.
Si la clé existe uniquement dans le premier objet, il s’agit d’une propriété supprimée.
Si la clé existe dans les deux objets, l’outil compare récursivement les deux valeurs.

L’ordre des clés n’a aucune importance. La norme JSON ne définit pas d’ordre pour les membres d’un objet. {"a":1,"b":2} et {"b":2,"a":1} sont donc considérés comme identiques.

Comparaison des tableaux JSON

Les tableaux sont comparés selon leur position, et non selon leur contenu. L’outil parcourt les deux tableaux indice par indice et compare l’élément présent à chaque indice, jusqu’à la longueur du plus long tableau. Si l’un des tableaux est plus court, les éléments supplémentaires à la fin du plus long sont signalés comme ajoutés ou supprimés.

Cela signifie que l’outil n’essaie jamais de mettre les éléments d’un tableau en correspondance selon leur contenu. Il ne détecte pas qu’un objet a été « déplacé » de l’indice 1 à l’indice 2 ; il constate seulement que la valeur présente à chaque indice a changé. La suppression ou l’insertion d’un élément au milieu d’un tableau décale tous les éléments suivants d’une position. Elle apparaît donc généralement comme plusieurs modifications distinctes plutôt que comme un ajout ou une suppression unique et claire.

Exemples détaillés

Exemple 1 : comparer deux objets

Premier JSON :

1{ "user": { "address": { "city": "New York", "zip": "10001" } } }
2

Deuxième JSON :

1{ "user": { "address": { "city": "Boston", "zip": "02108" } } }
2

Résultat :

user.address.city modifié : "New York" → "Boston"
user.address.zip modifié : "10001" → "02108"

Exemple 2 : modification à la fin d’un tableau

Premier JSON :

1{ "tags": ["important", "urgent", "review"] }
2

Deuxième JSON :

1{ "tags": ["important", "critical", "review", "documentation"] }
2

L’indice 0 est inchangé, l’indice 1 a changé, l’indice 2 est inchangé et l’indice 3 existe uniquement dans le deuxième tableau. Résultat :

tags[1] modifié : "urgent" → "critical"
tags[3] ajouté : "documentation"

Exemple 3 : suppression d’un élément au milieu d’un tableau

Cet exemple montre ce qui se passe lorsqu’un élément est supprimé au milieu d’un tableau, car il s’agit d’une source fréquente de confusion.

Premier JSON :

1{
2  "products": [
3    { "id": 1, "name": "Laptop", "price": 999.99 },
4    { "id": 2, "name": "Mouse", "price": 24.99 },
5    { "id": 3, "name": "Keyboard", "price": 59.99 }
6  ]
7}
8

Deuxième JSON, avec la ligne « Mouse » supprimée et une ligne « Monitor » ajoutée à la fin :

1{
2  "products": [
3    { "id": 1, "name": "Laptop", "price": 899.99 },
4    { "id": 3, "name": "Keyboard", "price": 59.99 },
5    { "id": 4, "name": "Monitor", "price": 349.99 }
6  ]
7}
8

Une personne qui examine ces données dirait que « Mouse a été supprimé et Monitor a été ajouté ». Comme l’outil compare strictement les indices, il ne l’interprète pas ainsi. Il compare l’indice 0 avec l’indice 0, l’indice 1 avec l’indice 1 et l’indice 2 avec l’indice 2. Chaque champ situé après l’élément supprimé est donc mis en correspondance avec le mauvais objet. Le résultat réel est de sept modifications :

products[0].price modifié : 999.99 → 899.99
products[1].id modifié : 2 → 3
products[1].name modifié : "Mouse" → "Keyboard"
products[1].price modifié : 24.99 → 59.99
products[2].id modifié : 3 → 4
products[2].name modifié : "Keyboard" → "Monitor"
products[2].price modifié : 59.99 → 349.99

Pour obtenir un résultat plus clair lors de la comparaison de listes de ce type, il faut trier les deux tableaux ou utiliser les mêmes clés avant de les coller, par exemple en écrivant chaque liste dans le même ordre ou en mettant les objets en correspondance à l’aide d’un champ d’identifiant avant la comparaison.

Ce que l’outil ne fait pas

Il ne met pas les éléments des tableaux en correspondance selon leur contenu. Comme indiqué plus haut, il compare uniquement les positions d’indice et ne peut donc pas déterminer qu’un élément a été déplacé plutôt que modifié.
Il ne détecte pas les références circulaires. En pratique, il ne s’agit pas d’une limitation : les deux entrées proviennent de JSON.parse, qui construit toujours un arbre simple et ne peut jamais produire une valeur faisant référence à elle-même. Les références circulaires ne peuvent de toute façon pas exister dans un texte JSON valide.
Il ne propose pas de paramètre permettant de trier les tableaux avant la comparaison. Réorganiser les éléments de l’entrée avant de les coller est le seul moyen d’éviter l’effet de décalage des indices décrit plus haut.

Comment utiliser l’outil

Collez le premier document JSON dans la zone de gauche et le deuxième dans celle de droite.
L’outil les compare automatiquement dès que les deux zones contiennent du texte. Il est également possible de cliquer sur « Comparer » pour lancer l’opération manuellement.
Consultez la liste des résultats. Chaque ligne affiche un chemin, tel que user.age, et indique si l’élément a été ajouté, supprimé ou modifié, avec les anciennes et nouvelles valeurs affichées côte à côte.
Cliquez sur « Copier » pour copier les résultats au format texte brut.

Si une zone contient un texte qui n’est pas un JSON valide, l’outil affiche une erreur sous cette zone au lieu d’effectuer une comparaison. Lorsque les deux zones contiennent des valeurs invalides, les deux erreurs apparaissent simultanément.

Foire aux questions

Qu’est-ce qui constitue une différence entre deux valeurs JSON ?
Une propriété ou un élément de tableau est différent s’il existe dans un seul des deux documents, ou s’il existe dans les deux mais contient une valeur différente ou un type différent. Le changement du nombre 5 en chaîne "5" compte comme une modification, même si les deux valeurs peuvent sembler similaires.

L’ordre des éléments est-il important ?
Cela dépend du conteneur. Les objets JSON n’ont pas d’ordre défini pour leurs membres. Deux objets contenant les mêmes clés et les mêmes valeurs dans un ordre différent sont donc considérés comme identiques. Les tableaux sont ordonnés et l’outil les compare selon leur indice. Le déplacement d’un élément vers une autre position est donc signalé comme une série de modifications, et non comme un déplacement.

Que signifie un chemin de résultat égal à $ ?
Cela signifie que l’ensemble du document a changé, et non une seule partie. Cela se produit lorsque les deux entrées sont des types de valeurs différents au niveau supérieur, par exemple un tableau d’un côté et un objet de l’autre, ou les nombres simples 1 et 2. $ est l’identifiant racine de la RFC 9535, la norme JSONPath.

Mes données JSON sont-elles envoyées à un serveur ?
Non. La comparaison s’effectue dans le navigateur à l’aide de JavaScript. Aucune donnée n’est téléversée.

La mise en forme, comme l’indentation ou la réduction, a-t-elle une incidence sur le résultat ?
Non. Les deux entrées sont analysées en valeurs JSON avant la comparaison. Les espaces, l’indentation et les sauts de ligne ne changent donc rien. Seules les données réelles sont comparées.

L’outil peut-il comparer du JSON contenant des commentaires ou des virgules finales ?
Non. Le JSON standard, défini dans la RFC 8259, n’autorise ni les commentaires ni les virgules finales. Une entrée qui en contient est rejetée comme non valide.

Références

IETF. « The JavaScript Object Notation (JSON) Data Interchange Format. » RFC 8259, décembre 2017.
IETF. « JavaScript Object Notation (JSON) Patch. » RFC 6902, avril 2013.
IETF. « JSONPath: Query Expressions for JSON. » RFC 9535, février 2024. (La section 2.2 définit l’identifiant racine $.)
Mozilla Developer Network. « JSON.parse(). »

Outil de Comparaison JSON - Comparez JSON en Ligne Gratuitement | Différence JSON