Comparateur de JSON

Comparateur JSON - Trouvez les différences

La comparaison de JSON est la base d'innombrables flux de développement : comparer des snapshots de réponses API, auditer des changements de configuration, déboguer des mutations d'état dans Redux/Zustand, examiner les dérives d'infrastructure-as-code et valider les migrations de données. Contrairement à un diff de texte brut, une comparaison consciente du JSON comprend la structure de vos données — elle sait que {a:1, b:2} et {b:2, a:1} sont identiques malgré un ordre de clés différent, que null et undefined se comportent différemment, et que les décalages d'éléments de tableau ne devraient pas se cascader en changements parasites. Cet outil effectue une comparaison récursive profonde, signale les différences avec des chemins complets en notation pointée (ex. user.preferences.theme), et les affiche dans une vue codée par couleur (vert=ajouté, rouge=supprimé, jaune=modifié) pour que vous puissiez voir exactement ce qui a changé.

Qu'est-ce qu'un JSON Diff Checker ?

C'est un outil qui compare deux objets JSON et met en lumière leurs différences :

- Repérer les changements entre versions
- Déboguer les réponses d'API
- Comparer des fichiers de configuration
- Suivre les modifications de données
- Vérifier les mises à jour JSON

Les propriétés ajoutées, retirées et modifiées sont clairement signalées.

Comment l'utiliser ?

1. Collez le premier JSON dans « JSON 1 »
2. Collez le second dans « JSON 2 »
3. Cliquez sur « Comparer »
4. Analysez les sections colorées (ajouts en vert, suppressions en rouge, modifications détaillées).

Quels types de différences sont détectés ?

L'outil détecte :

- Propriétés ajoutées
- Propriétés supprimées
- Valeurs modifiées
- Changements de type
- Différences dans les objets imbriqués
- Différences dans les tableaux (éléments ajoutés/supprimés/modifiés)

Puis-je comparer de gros JSON ?

Oui, mais les très gros fichiers (>5 Mo) peuvent prendre plus de temps. Fermez les onglets inutilisés et assurez-vous que les JSON sont bien formatés pour de meilleures performances.

Et les objets imbriqués/les tableaux ?

Les structures imbriquées sont gérées à tous les niveaux : l'outil indique le chemin complet vers chaque changement. Pour les tableaux, il parcourt élément par élément par index, détecte les éléments ajoutés et supprimés à leur index exact, et signale les changements imbriqués à l'intérieur des tableaux d'objets (ex. data.items[2].name) en affichant la position d'index entre crochets, même au fond de grands tableaux.

Mes données sont-elles en sécurité ?

Oui. La comparaison s'exécute à 100 % dans votre navigateur : aucun envoi ni stockage, pas de traçage. L'outil fonctionne même hors ligne après chargement.

Pourquoi deux JSON apparemment identiques sont-ils signalés comme différents ?

Six causes courantes : (1) Les espaces à l'intérieur des valeurs de chaîne comptent — 'hello' et 'hello ' sont différents. (2) Précision numérique : 0.1 + 0.2 en JavaScript produit 0.30000000000000004, qui n'est pas égal à 0.3 si l'un des côtés a été analysé à partir d'une telle somme. (3) Les zéros de fin après une virgule décimale sont supprimés lors de l'analyse, donc '1.0' et '1' comparent égaux après analyse mais diffèrent en tant que chaînes. (4) Booléens vs chaînes : 'true' et true sont des types différents. (5) null vs clé manquante — {a: null} a une clé, {} n'en a pas. (6) Les caractères Unicode invisibles comme zero-width space (U+200B) ou non-breaking space (U+00A0) paraissent identiques dans les éditeurs mais diffèrent au niveau octet. Pour déboguer, copiez chaque chaîne suspecte dans un outil qui révèle les caractères invisibles.

En quoi JSON Patch (RFC 6902) diffère-t-il d'un diff visuel ?

JSON Patch est un format normalisé (IETF RFC 6902, 2013) qui exprime les différences sous forme de liste ordonnée d'opérations : {op:'add', path:'/users/2', value:{...}}, {op:'replace', path:'/title', value:'Nouveau'}, {op:'remove', path:'/draft'}. Appliquer ce patch séquentiellement au JSON original produit la version modifiée — rendant les patchs portables, lisibles par machine et applicables côté serveur. Les diffs visuels (comme cet outil) sont conçus pour être lus par des humains ; JSON Patch est conçu pour être appliqué par des systèmes. De nombreuses API (Kubernetes, GitHub, JSON:API) acceptent les requêtes PATCH au format JSON Patch. Pour le diffing bidirectionnel dans les bases de données, JSON Merge Patch (RFC 7396) est plus simple mais plus avec perte — il ne peut pas représenter les insertions d'éléments de tableau, seulement les remplacements complets de tableau.

Cet outil gère-t-il la comparaison de tableaux intelligemment ?

Oui — cet outil parcourt les tableaux élément par élément par index au lieu de déverser les deux tableaux en un seul bloc. Les tableaux sont intrinsèquement ordonnés, donc la position compte par défaut : [1,2,3] est différent de [3,2,1] même s'ils contiennent les mêmes éléments. Un seul champ modifié dans un tableau de 500 éléments ne signale que cet élément, pas deux blocs géants ancien/nouveau. Exemple concret : comparer {"a":[1,2,3]} avec {"a":[1,9,3]} produit une seule différence MODIFIED au chemin a[1] (Avant : 2, Après : 9). Comparer [{"id":1,"v":"x"}] avec [{"id":1,"v":"y"}] produit une différence MODIFIED à [0].v. Ajouter un élément ({"a":[1,2]} vs {"a":[1,2,3]}) signale ADDED à a[2]. Pour les tableaux où l'ordre ne devrait pas compter (ensembles, listes d'éléments indépendants), il n'y a aucun moyen universel de savoir si vous voulez une comparaison d'ensembles ou une comparaison ordonnée — vous devez trier les deux tableaux avant le diff, ou utiliser un comparateur personnalisé. Pour les tableaux d'objets avec un champ id stable (ex. lignes de base de données), l'approche la plus précise est de trier par id puis de faire le diff, ce qui empêche une seule insertion au milieu de cascader en chaque index suivant étant marqué comme 'changé'. L'algorithme Myers diff utilisé par git est optimal pour ce cas mais rarement implémenté dans les outils JSON en raison du coût.

Diff JSON vs git diff — et comment comparer deux réponses d'API ?

git diff est basé sur les lignes et orienté texte : il voit un fichier JSON comme des lignes de caractères, donc réordonner les clés, reformater l'indentation ou mettre un long tableau sur une seule ligne apparaissent comme du bruit même si les données sont identiques. Un diff JSON (cet outil) est conscient de la structure : il analyse les deux côtés et compare les arbres résultants, donc {"a":1,"b":2} et {"b":2,"a":1} sont signalés comme identiques, et un seul champ modifié au fond d'un tableau apparaît comme un chemin tel que results[3].status au lieu d'une ligne entière réécrite. Pour comparer deux réponses d'API : capturez les deux corps (curl, l'onglet Réseau de votre navigateur → Copier comme réponse, ou une exécution enregistrée de Postman/Insomnia), collez le premier dans JSON 1 et le second dans JSON 2, puis cliquez sur Comparer. La sortie liste exactement quelles clés ont été ajoutées, supprimées ou modifiées et à quel index de tableau — idéal pour repérer une régression entre un endpoint de staging et de production, un changement de contrat après un déploiement, ou une dérive entre deux configs d'environnement. Comme tout s'exécute dans votre navigateur, vous pouvez coller en toute sécurité des réponses contenant des jetons ou des données personnelles sans les envoyer nulle part.

Quel est le plus grand JSON que je peux comparer ici ?

La mémoire du navigateur est la limite pratique, pas la taille du fichier. Les navigateurs de bureau modernes (Chrome, Firefox) gèrent confortablement deux JSON de 50-100 Mo en mémoire ; les navigateurs mobiles plafonnent plus près de 20-50 Mo. La partie la plus lente n'est pas le chargement mais le parcours récursif profond, qui est O(N) sur le nombre total de nœuds. Un JSON de 100 Mo avec 10 millions de clés imbriquées peut prendre 5-15 secondes pour faire le diff. Pour les fichiers plus grands, utilisez jq avec l'option --arg (jq -n --argjson a "$(cat a.json)" --argjson b "$(cat b.json)" '$a == $b') ou des outils de streaming-diff spécialisés comme json-diff-cli ou graphtage. Pour la comparaison programmatique dans le code de production, la fonction lodash _.isEqualWith avec un comparateur personnalisé est le standard JavaScript. Évitez de coller des journaux à l'échelle Go dans tout outil basé sur navigateur.

Puis-je exporter le résultat du diff comme rapport ?

Actuellement vous pouvez copier le diff visible dans le presse-papiers pour le partager dans les commentaires de revue de code, fils Slack ou messages de commit. Pour une exportation plus structurée, collez les deux JSON dans un outil CLI comme jd (json-diff) qui produit des patches de style Unix-diff, ou utilisez Node.js avec les bibliothèques deep-diff ou microdiff pour extraire programmatiquement le diff sous forme de tableau d'objets de changement (ex. {kind:'edit', path:['user','email'], lhs:'ancien@x', rhs:'nouveau@x'}). Pour les rapports visuels dans les pipelines QA, json-diff-kit rend une sortie HTML côte à côte adaptée à l'intégration dans les rapports d'échec de tests. La plupart des équipes font transiter le diff via CI/CD en tant que document JSON Patch — portable entre langages et applicable comme transformation programmatique.

Fonctionnalités clés

• Comparer deux objets JSON
• Détecter les propriétés ajoutées
• Détecter les propriétés supprimées
• Mettre en évidence les valeurs modifiées
• Coloration des différences
• Afficher les valeurs avant/après
• Gérer les objets et tableaux imbriqués
• Accepter de gros fichiers JSON
• Valider la syntaxe JSON
• Permuter rapidement les deux JSON
• Copier les différences
• Mode sombre
• Traitement 100 % local
• Fonctionnement hors ligne après chargement
• Interface responsive pour mobile