Skip to content

JSON Diff (Vergelijken)

Vergelijk twee JSON-bestanden direct in je browser. Zij-aan-zij markering, RFC 6902 JSON Patch-uitvoer, negeer storende velden zoals tijdstempels en ID's. 100% privé, geen upload.

Geen tracking Draait in je browser Gratis
Negeer paden:
Geavanceerde Opties
Array-modus
Reviewed for RFC 6902/6901 compliance and edge cases including null vs missing keys, type drift, floating-point precision, and array key alignment. — Go Tools API Tooling Team · May 4, 2026

Wat is JSON Diff?

JSON Diff is een structurele vergelijking van twee JSON-documenten die het datamodel van JSON respecteert — sleutels zijn ongeordend, typen zijn strikt, en arrays kunnen geordend of gesleuteld zijn. In tegenstelling tot een tekstdiff (die regels vergelijkt en sleutelherordeningen of witruimte als verschillen rapporteert), produceert een JSON diff semantisch betekenisvolle resultaten.

De canonieke machine-leesbare vorm is JSON Patch (RFC 6902), een geordende ops-array (add, remove, replace, move, copy, test) die het ene document omzet naar het andere. Paden gebruiken JSON Pointer (RFC 6901). Nauw verwant: JSON Merge Patch (RFC 7396) — eenvoudiger maar kan 'sleutel verwijderen' niet onderscheiden van 'sleutel instellen op null'. Dit gereedschap geeft RFC 6902 als uitvoer.

Diepe gelijkheid bij JSON in JavaScript is moeilijker dan het lijkt. JSON.stringify(a) === JSON.stringify(b) faalt bij sleutelherordening en misleidt bij -0 vs 0 (beide worden geserialiseerd als "0"). Een correcte diff moet beide bomen parallel doorlopen met sleutelset-unie, null onderscheiden van ontbrekend via de 'in'-operator, en bepalen wat 'gelijk' betekent voor getallen (Object.is standaard, epsilon voor tolerantie).

Dit gereedschap werkt volledig in je browser. Invoer verlaat je machine nooit. Veilig voor API-antwoorden, interne schema's en bedrijfseigen configuraties.

Werken met aangrenzende JSON-tools? Formatteer met JSON Formatter; converteer met JSON naar YAML en YAML naar JSON.

// Two JSON documents that look different but are semantically equal
const a = '{"a":1,"b":2}';
const b = '{"b":2,"a":1}';

// Naive comparison — wrong
JSON.stringify(JSON.parse(a)) === JSON.stringify(JSON.parse(b));
// → false (key order differs)

// JSON Diff (this tool) — correct: key order is irrelevant
// → 0 differences

// JSON Patch (RFC 6902) for { "a": 1 } → { "a": 2 }
// [{ "op": "replace", "path": "/a", "value": 2 }]

Belangrijkste Functies

Zij-aan-zij + JSON Patch

Twee weergaven vanuit één diff: visuele markering voor beoordeling, RFC 6902-patch voor automatisering.

Ruisvelden negeren

Éénklik-presets verwijderen /createdAt, /updatedAt, /*Id, /*At, requestId, traceId. Aangepaste Extended JSON Pointer-patronen worden ondersteund.

Arrays koppelen op sleutel

Vergelijk arrays van objecten op een id-veld in plaats van op index — voor K8s envs, package-lock-vermeldingen of elke logisch ongeordende lijst.

Type-strikt standaard

1 ≠ "1". null ≠ ontbrekend. Detecteer serialisatiedrift in backends zodra die in een testfixture terechtkomt.

100% browsergebaseerd

Invoer verlaat je machine nooit. Geen upload, geen localStorage van JSON, geen analytics op wat je plakt.

Deel configuratie, niet data

Deellink schrijft alleen je configuratie naar de URL. Je JSON-invoer blijft lokaal.

Voorbeelden

API Response Regressie

{"user":{"id":1,"name":"Ada","createdAt":"2024-01-01"}}
{"user":{"id":1,"name":"Ada Lovelace","createdAt":"2024-02-02"}}

Twee wijzigingen (naam + createdAt). Voeg /user/createdAt toe aan Negeer paden en alleen de naamwijziging blijft over.

Configuratiebestand Audit (Sleutelvolgorde)

{"a":1,"b":2,"c":3}
{"c":3,"a":1,"b":2}

Zelfde data, andere sleutelvolgorde. JSON Diff beschouwt sleutelvolgorde als semantisch irrelevant — diff is leeg.

Array van Objecten (Koppelen op sleutel)

[{"id":1,"qty":3},{"id":2,"qty":5}]
[{"id":2,"qty":5},{"id":1,"qty":4}]

Schakel Array-modus naar 'Koppelen op sleutel' met sleutel=id. Zonder uitlijning lijkt elk element gewijzigd; met uitlijning wijzigt alleen qty bij id=1.

JSON Patch-uitvoer (RFC 6902)

{"items":[{"id":1,"price":29.99}]}
{"items":[{"id":1,"price":24.99}]}

Schakel naar het JSON Patch-tabblad voor [{"op":"replace","path":"/items/0/price","value":24.99}], toe te passen met fast-json-patch.

Gebruiksaanwijzing

  1. 1

    Plak beide JSON-documenten

    Plak de originele (links) en gewijzigde (rechts) JSON. Live diff wordt direct weergegeven terwijl je typt; grote invoer (>200 KB) schakelt over naar een handmatige Diff-knop.

  2. 2

    Filter de ruis

    Klik op een preset (Tijdstempels / ID's / Trace) of plak Extended JSON Pointer-patronen in Negeer paden om irrelevante velden te verwijderen.

  3. 3

    Kies de gewenste weergave

    Zij-aan-zij voor menselijke beoordeling, JSON Patch (RFC 6902) voor machine-toepasbare ops. Gebruik Deellink om de configuratie met een teamlid te delen.

Veelvoorkomende Diff-valkuilen

Sleutelvolgorde-ruis (Tekstdiff-symptoom)

Als je diff-tool {"a":1,"b":2} vs {"b":2,"a":1} als verschillend rapporteert, doet het een regelgebaseerde diff, geen JSON diff. JSON-sleutels zijn ongeordend — dit gereedschap negeert sleutelvolgorde automatisch.

✗ Fout
diff a.json b.json   # text diff: 'everything changed'
✓ Correct
JSON Diff (this tool): 0 differences

Null vs Ontbrekend Verwarring

{"a":null} en {} zijn niet hetzelfde. Ze gelijk behandelen maskeert echte backend-bugs.

✗ Fout
{"a": null} == {}   # collapsed by some tools
✓ Correct
{"a": null} ≠ {}     # type-strict diff

Arrayvolgorde zonder sleuteluitlijning

[{id:1},{id:2}] vs [{id:2},{id:1}] zijn niet 'twee wijzigingen' voor een logische set. Sequentieel rapporteert dat wel; schakel naar Koppelen op sleutel.

✗ Fout
Sequential diff: 4 modified
✓ Correct
Match by key (id): 0 differences

Type-drift (Getal vs String)

Backends serialiseren ID's soms inconsistent — 42 vs "42". Het gereedschap markeert deze als 'type'-wijzigingen zodat je de drift vroeg kunt detecteren.

✗ Fout
{"id": 42} vs {"id": "42"}   # serialization bug
✓ Correct
Diff reports 'modified (type)' with both values

Drijvende-kommaprecisie

0.1 + 0.2 !== 0.3 in IEEE 754. Met tolerantie=0 (standaard) wordt dit gemarkeerd. Stel tolerantie in op 1e-9 als je numerieke equivalentie bedoelt.

✗ Fout
tolerance=0:  0.30000000000000004 ≠ 0.3
✓ Correct
tolerance=1e-9: equal

Tijdstempel- & UUID-ruis

createdAt, updatedAt, requestId, traceId veranderen bij elk verzoek. Gebruik de Negeer paden-presets om ze te verwijderen.

✗ Fout
Diff: 47 modifications (45 are timestamps)
✓ Correct
Add /createdAt, /updatedAt, /requestId to Ignore paths → 2 real changes

Veelvoorkomende Gebruikssituaties

API Response Regressie
Vergelijk staging- vs productieantwoorden; negeer tijdstempels en verzoek-ID's om alleen betekenisvolle payload-wijzigingen te zien.
CI Snapshot-testfouten
Plak actual vs expected uit een falende Jest/Vitest-snapshot. Filter ruis en vind de echte wijziging in seconden.
package-lock / yarn.lock Conflicten
Los merge-conflicten op door afhankelijkheden op naam uit te lijnen; sleutelvolgorde en niet-gerelateerde velden zijn geen ruis meer.
K8s / Helm Values Audit
Koppel envs, volumeMounts en ports op naam. Detecteer onbedoelde herordeningen versus echte configuratiewijzigingen.
i18n Vertaaldekking
Vergelijk en.json structureel met zh.json om ontbrekende of extra vertaalsleutels te vinden zonder waarde-ruis.
Terraform / CDK Plan Review
Vergelijk planuitvoer tussen runs; numerieke tolerantie verwerkt drijvende-komma-rekenkunde, negeer paden verwijderen ARN's en tijdstempels.

Technische Details

RFC 6902-conforme Patch-uitvoer
Genereert geldige JSON Patch-ops (add/remove/replace) met RFC 6901-paden. Gevalideerd tegen fast-json-patch@3.x en het npm-pakket rfc6902.
Iteratieve Doorloop
Expliciete-stack-doorloop (geen recursie) begrensd op 100.000 knooppunten en diepte 64 om stack overflow bij kwaadaardige invoer te voorkomen.
Object.is Numerieke Gelijkheid
Standaard numerieke tolerantie is 0 — gebruikt Object.is zodat -0 en +0 worden onderscheiden. Stel tolerantie > 0 in voor epsilon-gebaseerde gelijkheid.

Best Practices

Filter voor je beoordeelt
Voeg eerst Negeer paden toe (tijdstempels, ID's, tracevelden), lees dan de diff. Ruizige diffs bekijken traint het oog om over echte wijzigingen heen te kijken.
Koppelen op sleutel voor logische sets
Als je array een ongeordende set vertegenwoordigt (envs, gebruikers, afhankelijkheden), gebruik Koppelen op sleutel. Sequentiële diff op logische sets is bijna altijd onjuist.
Deel configuratie, niet invoer
Gebruik Deellink om een collega je filterconfiguratie te sturen — plak nooit gevoelige JSON in gedeelde documenten. De URL bevat alleen de configuratie.

Veelgestelde Vragen

Waarom toont mijn diff alles als gewijzigd terwijl ik maar één veld heb aangepast?
Drie gebruikelijke oorzaken: (1) andere sleutelvolgorde — JSON Diff beschouwt sleutelvolgorde als equivalent, tekstdiff-tools niet; (2) tijdstempels/UUID's/auto-ID's die bij elk verzoek veranderen — voeg ze toe aan Negeer paden; (3) arrayvolgorde, wanneer vergelijking op index niet van toepassing is — schakel Array-modus naar 'Koppelen op sleutel'.
Hoe negeer ik tijdstempels en ID's in de JSON diff?
Gebruik de invoer voor Negeer paden hierboven. Klik op de preset 'Tijdstempels' of 'ID's' voor éénklik-filtering van /createdAt, /updatedAt, /*Id, /*At, /requestId. Je kunt ook eigen Extended JSON Pointer-patronen plakken — één per regel — voor geavanceerde filtering.
Wat is het verschil tussen JSON Patch en een visuele diff?
Visuele (zij-aan-zij) diff is voor mensen — beoordeel wijzigingen met het oog. JSON Patch (RFC 6902) is voor machines — een gestructureerde ops-array (add/remove/replace) die je kunt toepassen met de npm-pakketten fast-json-patch of rfc6902. Zelfde diff, twee uitvoerformaten.
Behandelt JSON diff null en ontbrekende sleutels hetzelfde?
Nee. {"a":null} en {} zijn verschillend — de eerste heeft een expliciete null, de tweede heeft geen sleutel. Echte systemen gedragen zich anders voor de twee; dit gereedschap houdt ze onderscheiden.
Hoe worden arrays vergeleken — op index of op sleutel?
Standaard op index (Sequentieel). Schakel naar 'Koppelen op sleutel' en geef een sleutelveld op (vaak id) om elementen ongeacht volgorde uit te lijnen. Gebruik dit voor K8s envs, package-lock-vermeldingen of elke lijst die logisch een set is.
Kan ik de diff exporteren als RFC 6902 JSON Patch?
Ja. Het JSON Patch-tabblad geeft een geldige RFC 6902 ops-array. Als Negeer paden zijn ingesteld, wordt de patch gefilterd (het tabblad toont '(gefilterd: sluit {n} genegeerde paden uit)') en maakt hij de originelen niet exact terug. Wis Negeer paden voor een volledige patch.
Is JSON Patch hetzelfde als JSON Merge Patch (RFC 7396)?
Nee. RFC 6902 (JSON Patch) is een geordende ops-array — expliciet en omkeerbaar. RFC 7396 (Merge Patch) is een enkel merge-document — eenvoudiger maar kan verwijdering niet onderscheiden van instellen op null. JSON Diff geeft RFC 6902 als uitvoer.
Hoe vergelijk ik twee grote JSON-bestanden (>10 MB)?
Bestanden groter dan ~5 MB overschrijden het praktische browsergeheugen. Live-modus schakelt uit bij 200 KB; voor bestanden van meerdere megabytes gebruik je commandoregeltools zoals jq of fast-json-patch in Node.
Stuurt het gereedschap mijn JSON naar een server?
Nee. Alle vergelijking wordt lokaal in je browser uitgevoerd. Invoer wordt nooit naar schijf, netwerk, localStorage of URL-parameters geschreven. De pagina vernieuwen wist ze. De knop Deellink schrijft alleen je configuratie (Array-modus, Negeer paden) — nooit je data.
Waarom verschilt 42 van "42" in de diff?
JSON Diff is type-strikt: getal 42 en string "42" zijn niet gelijk. Dit detecteert serialisatiedrift in backends (sommige endpoints geven numerieke ID's, andere strings) — de diff labelt het als 'type'-wijziging.
Kan ik JSON met commentaar (JSONC) of afsluitende komma's vergelijken?
Standaard JSON (RFC 8259) staat geen commentaar of afsluitende komma's toe. Dit gereedschap gebruikt native JSON.parse, dat beide afwijst. Verwijder commentaar eerst met JSON Formatter.
Hoe vergelijk ik geneste arrays van objecten op een sleutel zoals id?
Stel Array-modus in op 'Koppelen op sleutel' en voer id in. Diff lijnt uit op id-waarden. v1 past hetzelfde sleutelveld toe op elke arraydiepte; inner arrays zonder dat veld vallen terug op sequentieel en tonen een waarschuwingschip.
Verwerkt de diff drijvende-kommaprecisie (0.1 + 0.2)?
Ja, met Numerieke tolerantie. Standaard is 0 met Object.is — dus -0 vs +0 worden gemarkeerd. Stel tolerantie in op een kleine epsilon (bijv. 1e-9) en 0.1 + 0.2 wordt gelijk beschouwd aan 0.3. Tolerantie geldt alleen voor numerieke bladeren.

Gerelateerde tools

Alle tools bekijken →