Fusionneur d'objets JSON

1. 1Ajoutez vos documentsDéposez jusqu'à cinq fichiers .json, .jsonc, .jsonl ou .ndjson, ou cliquez sur Coller du JSON pour saisir un document. L'ordre compte : les documents ultérieurs l'emportent en cas de désaccord, et les flèches de chaque ligne le modifient.
2. 2Choisissez la combinaison des objetsLa fusion profonde combine les objets imbriqués récursivement. La fusion superficielle ne combine que les clés de premier niveau et remplace les objets imbriqués en entier. Réglez la politique des nulls si un null explicite ne doit pas effacer une valeur existante.
3. 3Choisissez la combinaison des tableauxRemplacer conserve le dernier tableau, Concaténer les met bout à bout, Union les réunit sans doublons, et Fusionner par clé combine les enregistrements partageant une clé telle que id.
4. 4Fusionnez et vérifiezAppuyez sur Fusionner. Le rapport de conflits liste chaque chemin où un document ultérieur a écrasé une valeur antérieure, avec les deux valeurs, et le rapport des entrées montre les clés en double et les avertissements de précision de chaque source.
5. 5Téléchargez ou copiezChoisissez une indentation, ou NDJSON lorsque le résultat est un tableau, puis téléchargez ou copiez. Si vous modifiez un réglage ensuite, le résultat est marqué comme périmé jusqu'à ce que vous le réappliquiez.

Fusionnez jusqu'à cinq documents JSON en un seul. Ils se combinent dans l'ordre où vous les placez, donc les derniers l'emportent en cas de désaccord, et les flèches de chaque ligne modifient cet ordre. N'importe quelle racine JSON fonctionne : objets, tableaux et valeurs simples. Les objets imbriqués peuvent fusionner récursivement ou être remplacés en entier, les tableaux disposent de quatre stratégies propres, et chaque valeur écrasée est consignée, de sorte que le résultat se vérifie au lieu de se croire.

• Autant de documents que voulu, dans n'importe quel ordre — Déposez des fichiers, collez du texte, ou les deux. Réordonnez les lignes pour changer quel document l'emporte. Cinq documents avec l'offre gratuite, et l'ordre est la seule garantie de priorité de l'outil.
• Profonde ou superficielle, et quatre stratégies de tableaux — Les objets fusionnent récursivement ou seulement au premier niveau. Les tableaux se remplacent, se concatènent, forment une union sans doublons, ou fusionnent enregistrement par enregistrement sur un champ clé.
• Un rapport de conflits, pas seulement un résultat — Chaque chemin où un document ultérieur a remplacé une valeur antérieure, avec les deux valeurs et le document gagnant. Aucun autre outil de fusion JSON en ligne n'en publie.
• Il lit le JSON que vous avez réellement — Commentaires et virgules finales, NDJSON, UTF-16, marques d'ordre des octets. Chacun est un fichier qu'un analyseur strict déclare cassé et que tous les éditeurs affichent comme correct.

Propulsé par des algorithmes de traitement optimisés.

C'est la décision qui change le plus le résultat, et les deux réponses sont réellement différentes plutôt que l'une meilleure que l'autre.

La fusion superficielle ne combine que le premier niveau. Si une clé existe dans les deux documents, la valeur ultérieure remplace complètement la précédente, et « complètement » inclut les objets imbriqués : un objet de base à dix clés imbriquées disparaît dès qu'un document ultérieur mentionne cette clé. La fusion profonde descend au contraire dans les objets imbriqués et les combine clé par clé, de sorte qu'une surcharge ne touche que les clés qu'elle nomme.

Fusionner {"server": {"host": "localhost", "port": 8080}} avec {"server": {"port": 9090}} donne {"server": {"port": 9090}} en fusion superficielle — l'hôte a disparu — et {"server": {"host": "localhost", "port": 9090}} en fusion profonde. Profonde est le mode par défaut ici parce que superposer de la configuration est ce pour quoi on vient chercher un outil de fusion, et c'est ce que font lodash.merge et toutes les bibliothèques comparables.

La fusion profonde n'a rien à dire sur les tableaux : deux tableaux ne sont pas deux objets, et il n'existe pas une façon unique et correcte de les combiner. La plupart des bibliothèques choisissent discrètement un comportement sans jamais le mentionner. Cet outil pose la question.

• Remplacer — Le tableau ultérieur l'emporte. C'est ce que fait conventionnellement la fusion profonde et ce que font la plupart des bibliothèques sans vous le dire. C'est le mode par défaut ici.
• Concaténer — Tous les éléments des deux tableaux, dans l'ordre, doublons compris. Adapté aux journaux, aux flux d'événements et à tout ce dont chaque entrée est un enregistrement à part entière.
• Union — Les deux tableaux réunis, puis les doublons retirés en comparant la structure plutôt que l'identité : {"a":1,"b":2} et {"b":2,"a":1} comptent pour le même élément.
• Fusionner par clé — Traite les deux tableaux comme des ensembles d'enregistrements et combine ceux qui partagent un champ clé. Détaillé plus bas.

La stratégie des tableaux s'applique partout où deux tableaux se rencontrent, en mode superficiel comme en mode profond. La rendre inerte en mode superficiel laisserait à l'écran un réglage qui, silencieusement, ne fait rien.

Fusionner par clé est la stratégie qui transforme deux tableaux d'enregistrements en un seul. Indiquez le champ clé — id par défaut — et les enregistrements correspondants se combinent champ par champ au lieu qu'un tableau remplace l'autre.

• Les enregistrements correspondants fusionnent — Un enregistrement d'un document ultérieur dont la clé correspond à un antérieur y est fusionné avec les mêmes règles d'objets que partout ailleurs, de sorte que ses champs s'ajoutent au lieu de remplacer tout l'enregistrement.
• Les nouveaux enregistrements sont ajoutés — Un enregistrement dont la clé n'est pas déjà présente est ajouté à la fin, en préservant l'ordre du document antérieur.
• Les enregistrements sans la clé sont laissés tels quels — Les éléments qui ne sont pas des objets, ou les objets qui ne portent pas le champ clé, sont ajoutés sans modification plutôt que devinés.
• Le type fait partie de la clé — Le nombre 1 et la chaîne "1" sont des enregistrements distincts et ne se joignent pas. Les traiter comme égaux est le bug classique des jointures, et il produit un résultat qui paraît parfaitement raisonnable et qui est faux.

JSON n'a pas d'undefined, donc null porte deux sens à la fois : c'est une vraie valeur, et c'est la seule façon pour une couche de configuration de dire « annule ce qui était ici ». Les deux lectures sont légitimes et aucune bibliothèque ne peut deviner laquelle vous vouliez. Par défaut un null ultérieur écrase, parce que null est une valeur. Passez la politique des nulls sur Ignorer et un null d'un document ultérieur est entièrement sauté, de sorte qu'il ne pourra jamais effacer ce qu'un document de base a défini. Le rapport compte combien de nulls ont été ignorés, si bien qu'un mauvais choix se voit au lieu de passer inaperçu.

Les objets JSON n'ont pas d'ordre de clés formellement défini, mais en pratique tous les analyseurs et tous les sérialiseurs préservent l'ordre d'écriture — ce qui signifie que cet ordre apparaît dans le diff de votre gestionnaire de versions. Par défaut le résultat conserve l'ordre du document de base et ajoute à la fin les nouvelles clés des documents ultérieurs, ce qui produit le plus petit diff possible. Triez de A à Z lorsque vous voulez une sortie stable quelle que soit la façon dont les entrées ont été écrites, ce qui convient à un fichier que plusieurs outils régénèrent.

Un outil de fusion qui ne vous donne que le fichier fusionné vous demande de le croire sur parole. Celui-ci consigne chaque endroit où une valeur a été perdue.

Un conflit est tout chemin où un document ultérieur a remplacé une valeur antérieure au lieu d'y fusionner : une valeur simple sur une valeur simple, un tableau sur un tableau, ou un objet sur un objet en fusion superficielle. Le rapport donne le chemin, la valeur remplacée, celle qui l'a remplacée et le document gagnant. Les valeurs fusionnées plutôt que remplacées ne sont pas des conflits, pas plus qu'un document ultérieur écrivant la valeur identique : les deux seraient du bruit. À côté, le rapport des entrées liste ce qui a été trouvé dans chaque document source avant le début de la fusion.

Deux choses que tous les analyseurs JSON écartent silencieusement, et qui changent toutes deux le contenu de votre fichier fusionné.

• Clés en double — {"a": 1, "a": 2} est du JSON valide et tous les analyseurs conservent la dernière, en écartant le fait qu'il y en avait deux. Si le doublon était une erreur, la fusion que vous vérifiez n'est pas celle que vous avez écrite. Chaque document source indique combien de clés en double il contenait et où.
• Nombres qui ne survivent pas à l'aller-retour — Les nombres JavaScript sont des doubles IEEE-754 et portent 15 à 17 chiffres significatifs. Un identifiant de base de données 64 bits comme 9007199254740993 devient 9007199254740992 dans tous les analyseurs JSON de tous les navigateurs, si bien que le fichier fusionné contient un identifiant différent de l'entrée. Il n'y a pas de correctif dans le modèle de données de JSON, donc l'outil le signale au lieu de prétendre le contraire.

Le JSON strict et le JSON que les gens ont réellement sur disque ne sont pas la même chose. Quatre différences expliquent presque tous les fichiers qui « sont valides partout sauf dans mon programme ».

• Commentaires — tsconfig.json, .eslintrc.json et tous les devcontainer.json comportent des commentaires // et /* */. JSON.parse les rejette. Ici ils sont reconnus, comptés et fusionnés.
• Virgules finales — L'autre moitié de la configuration éditée à la main. Également rejetée par JSON.parse, également gérée ici.
• NDJSON et JSON Lines — Un document par ligne, c'est ainsi qu'arrivent les exports de journaux et les résultats d'API en flux. Détecté automatiquement et lu comme un tableau, et disponible en format de sortie quand le résultat fusionné est un tableau.
• Marques d'ordre des octets — PowerShell écrit de l'UTF-16 avec une marque par défaut et .NET écrit de l'UTF-8 avec une. Décodé comme du simple UTF-8, un fichier UTF-16 devient du charabia et tous les analyseurs accusent le premier caractère. La marque est lue d'abord et décide de l'encodage.

Presque toutes les fusions JSON relèvent d'une poignée de tâches, et savoir laquelle vous faites suffit généralement à fixer les réglages.

• Superposer de la configuration — Une configuration de base, puis des surcharges d'environnement, puis locales. Fusion profonde, ordre d'origine des clés, et Ignorer les nulls si vos fichiers de surcharge utilisent null comme commentaire.
• Combiner des réponses d'API — Plusieurs réponses en un objet. Fusion profonde, et Fusionner par clé si les réponses portent des tableaux d'enregistrements à aligner sur un id.
• Joindre des ensembles d'enregistrements — Deux exports des mêmes entités avec des champs différents. Fusionner par clé sur l'identifiant commun en fait un ensemble complet.
• Consolider des traductions — Des fichiers de langue répartis entre équipes ou fonctionnalités. Fusion profonde avec tri A-Z donne un fichier stable qui se compare proprement à chaque régénération.
• Assembler des jeux de test — Un jeu par défaut plus des surcharges par cas, pour que chaque test n'énonce que ce qui le distingue.

• Mode de fusion — Profonde combine les objets imbriqués récursivement. Superficielle ne combine que les clés de premier niveau et remplace les objets imbriqués en entier.
• Tableaux — Remplacer, Concaténer, Union (doublons retirés) ou Fusionner par clé.
• Champ clé — Le champ qui identifie un enregistrement pour Fusionner par clé. id par défaut. Comparé par type autant que par valeur.
• Nulls — Écraser, pour qu'un null explicite remplace une valeur, ou Ignorer, pour qu'il n'en efface jamais.
• Ordre des clés — Origine conserve l'ordre du document de base et ajoute les nouvelles clés à la fin. A-Z trie chaque objet pour un diff stable.
• Indentation — Minifié, 2 espaces, 4 espaces ou tabulation.
• Sortie — JSON, ou NDJSON quand le résultat fusionné est un tableau.
• Accepter commentaires et virgules finales — Activé par défaut. Désactivez-le pour exiger du JSON strict de chaque document.
• Réinitialiser — Efface tous les documents, le résultat et tous les réglages, et revient aux valeurs par défaut.

L'offre gratuite accepte cinq documents, jusqu'à 10 Mo chacun et 30 Mo au total. Le total est le nombre qui contraint le plus souvent, car une fusion garde en mémoire toutes les entrées et le résultat en même temps. Tous les réglages qui décident si la fusion est correcte sont gratuits : les deux modes, les quatre stratégies de tableaux, le champ clé, la politique des nulls, l'ordre des clés, les quatre indentations, les deux formats de sortie et les deux rapports. Pro n'augmente que l'échelle : plus de documents, la limite de votre propre appareil au lieu d'un plafond fixe, et un lot livré en une seule archive.

• Formateur JSON
• Validateur JSON
• Trier les clés JSON
• Comparer du JSON
• Minifier du JSON
• Supprimer des clés JSON
• Visionneuse JSON
• Échapper du JSON
• JSON vers YAML
• JSON vers XML
• CSV vers JSON
• Excel vers JSON
• Outils JSON