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 et traite les tableaux en montrant l'index des éléments modifiés.

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 ?

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. L'outil signale les différences à chaque index : 'index 0 changé de 1 à 3'. 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.

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