Skip to content

JSON Diff (Confronta)

Confronta due file JSON istantaneamente nel browser. Evidenziazione affiancata, output JSON Patch RFC 6902, ignora campi rumorosi come timestamp e ID. 100% privato, nessun upload.

Niente tracciamento Funziona nel browser Gratuito
Ignora percorsi:
Opzioni avanzate
Modalità array
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

Cos'è JSON Diff?

JSON Diff è un confronto strutturale di due documenti JSON che rispetta il modello dei dati JSON — le key non sono ordinate, i tipi sono strict e gli array possono essere ordinati o con key. A differenza di un diff testuale (che confronta le righe e segnala riordini di key o spazi come differenze), un JSON diff produce risultati semanticamente significativi.

La forma canonica leggibile dalla macchina è JSON Patch (RFC 6902), un array ordinato di operazioni (add, remove, replace, move, copy, test) che trasforma un documento nell'altro. I percorsi usano JSON Pointer (RFC 6901). Strettamente correlato: JSON Merge Patch (RFC 7396) — più semplice ma non può distinguere 'rimuovi key' da 'imposta key a null'. Questo tool produce output RFC 6902.

L'uguaglianza profonda su JSON in JavaScript è più difficile di quanto sembri. JSON.stringify(a) === JSON.stringify(b) fallisce con riordini di key, e inganna su -0 vs 0 (entrambi vengono serializzati come "0"). Un diff corretto deve percorrere entrambi gli alberi in parallelo usando l'unione degli insiemi di key, distinguere null da mancante tramite l'operatore 'in', e decidere cosa significa 'uguale' per i numeri (Object.is per default, epsilon per la tolleranza).

Questo tool viene eseguito interamente nel browser. Gli input non lasciano mai la tua macchina. Sicuro per risposte API, schemi interni e configurazioni proprietarie.

Hai bisogno di tool JSON correlati? Formatta con JSON Formatter; converti con JSON to YAML e YAML to 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 }]

Funzionalità principali

Affiancato + JSON Patch

Due viste da un unico diff: evidenziazione visiva per la revisione, patch RFC 6902 per l'automazione.

Ignora i campi rumorosi

I preset con un clic escludono /createdAt, /updatedAt, /*Id, /*At, requestId, traceId. Supportati pattern Extended JSON Pointer personalizzati.

Corrispondenza array per key

Confronta array di oggetti tramite un campo id anziché per indice — per env K8s, voci di package-lock o qualsiasi lista logicamente non ordinata.

Type-Strict per impostazione predefinita

1 ≠ "1". null ≠ mancante. Rileva la deriva della serializzazione del backend nel momento in cui compare in un test fixture.

100% basato sul browser

Gli input non lasciano mai la tua macchina. Nessun upload, nessun localStorage del JSON, nessuna analisi di ciò che incolli.

Condividi la configurazione, non i dati

Share Link scrive solo la tua configurazione nell'URL. I tuoi input JSON rimangono locali.

Esempi

Regressione risposta API

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

Due modifiche (name + createdAt). Aggiungi /user/createdAt a Ignora percorsi e rimane solo la modifica del nome.

Audit file di configurazione (riordino key)

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

Stessi dati, ordine delle key diverso. JSON Diff tratta l'ordine delle key come semanticamente irrilevante — il diff è vuoto.

Array di oggetti (corrispondenza per key)

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

Passa la modalità Array a 'Corrispondenza per key' con key=id. Senza allineamento ogni elemento appare modificato; con allineamento cambia solo qty sull'id=1.

Output JSON Patch (RFC 6902)

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

Passa al tab JSON Patch per ottenere [{"op":"replace","path":"/items/0/price","value":24.99}] applicabile con fast-json-patch.

Come si usa

  1. 1

    Incolla entrambi i documenti JSON

    Incolla il JSON originale (sinistra) e modificato (destra). Il diff live viene visualizzato mentre scrivi; input grandi (>200 KB) passano a un pulsante Diff manuale.

  2. 2

    Filtra il rumore

    Clicca un preset (Timestamps / IDs / Trace) o incolla pattern Extended JSON Pointer in Ignora percorsi per escludere i campi irrilevanti.

  3. 3

    Scegli la vista di cui hai bisogno

    Affiancata per la revisione umana, JSON Patch (RFC 6902) per operazioni applicabili dalla macchina. Usa Share Link per inviare la configurazione a un collega.

Errori comuni nel diff

Rumore nell'ordine delle key (sintomo del diff testuale)

Se il tuo tool di diff segnala {"a":1,"b":2} vs {"b":2,"a":1} come diversi, sta facendo un diff a riga, non un JSON diff. Le key JSON non sono ordinate — questo tool ignora automaticamente l'ordine delle key.

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

Confusione null vs mancante

{"a":null} e {} non sono la stessa cosa. Trattarli come uguali maschera veri bug del backend.

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

Ordine array senza allineamento per key

[{id:1},{id:2}] vs [{id:2},{id:1}] non sono 'due modifiche' per un insieme logico. Il sequenziale lo segnala come tale; passa a Corrispondenza per key.

✗ Errato
Sequential diff: 4 modified
✓ Corretto
Match by key (id): 0 differences

Deriva di tipo (Number vs String)

I backend a volte serializzano gli ID in modo incoerente — 42 vs "42". Il tool segnala questi come modifiche di 'tipo' così puoi individuare la deriva tempestivamente.

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

Precisione floating-point

0.1 + 0.2 !== 0.3 in IEEE 754. Con tolerance=0 (default), questo viene segnalato. Imposta tolerance a 1e-9 se intendi l'equivalenza numerica.

✗ Errato
tolerance=0:  0.30000000000000004 ≠ 0.3
✓ Corretto
tolerance=1e-9: equal

Rumore timestamp e UUID

createdAt, updatedAt, requestId, traceId cambiano a ogni richiesta. Usa i preset Ignora percorsi per escluderli.

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

Casi d'uso comuni

Regressione risposta API
Confronta le risposte di staging e produzione; ignora timestamp e ID delle richieste per evidenziare solo le modifiche significative al payload.
Errori nei test snapshot CI
Incolla il reale vs il previsto da uno snapshot Jest/Vitest fallito. Filtra il rumore e trova la vera modifica in pochi secondi.
Conflitti package-lock / yarn.lock
Risolvi i conflitti di merge allineando le dipendenze per nome; l'ordine delle key e i campi non correlati smettono di essere rumore.
Audit valori K8s / Helm
Abbina env, volumeMounts e port per nome. Rileva ordinamenti non intenzionali vs modifiche reali alla configurazione.
Copertura traduzione i18n
Confronta strutturalmente en.json con zh.json per trovare key di traduzione mancanti o in eccesso senza rumore sui valori.
Revisione piano Terraform / CDK
Confronta l'output del piano tra esecuzioni; la tolleranza numerica gestisce l'aritmetica floating-point, ignora percorsi esclude ARN e timestamp.

Dettagli tecnici

Output patch conforme RFC 6902
Genera operazioni JSON Patch valide (add/remove/replace) con percorsi RFC 6901. Verificato rispetto ai pacchetti npm fast-json-patch@3.x e rfc6902.
Attraversamento iterativo
Attraversamento con stack esplicito (senza ricorsione) con limite di 100.000 nodi e profondità 64 per prevenire stack overflow su input avversariali.
Uguaglianza numerica Object.is
La tolleranza numerica predefinita è 0 — usa Object.is quindi -0 e +0 sono distinti. Imposta tolleranza > 0 per l'uguaglianza basata su epsilon.

Best Practice

Filtra prima di revisionare
Aggiungi prima Ignora percorsi (timestamp, ID, campi trace), poi leggi il diff. Revisionare diff rumorosi addestra l'occhio a saltare — e perdere — le modifiche reali.
Corrispondenza per key per insiemi logici
Se il tuo array rappresenta un insieme non ordinato (env, utenti, dipendenze), usa Corrispondenza per key. Il diff sequenziale su insiemi logici è quasi sempre sbagliato.
Condividi la configurazione, non gli input
Usa Share Link per inviare a un collega la configurazione del filtro — non incollare mai JSON sensibili in documenti condivisi. L'URL contiene solo la configurazione.

Domande frequenti

Perché il diff mostra tutto cambiato quando ho modificato solo un campo?
Tre cause comuni: (1) ordine delle key diverso — JSON Diff tratta l'ordine delle key come equivalente, ma i tool di diff testuale no; (2) timestamp/UUID/auto-ID che cambiano a ogni richiesta — aggiungili a Ignora percorsi; (3) ordine degli array, quando il confronto per indice non è appropriato — passa la modalità Array a 'Corrispondenza per key'.
Come ignoro timestamp e ID nel JSON diff?
Usa il campo Ignora percorsi in alto. Clicca il preset 'Timestamps' o 'IDs' per filtrare con un clic /createdAt, /updatedAt, /*Id, /*At, /requestId. Puoi anche incollare i tuoi pattern Extended JSON Pointer — uno per riga — per un filtraggio avanzato.
Qual è la differenza tra JSON Patch e un diff visivo?
Il diff visivo (affiancato) è per gli esseri umani — revisione visiva delle modifiche. JSON Patch (RFC 6902) è per le macchine — un array strutturato di operazioni (add/remove/replace) applicabile con i pacchetti npm fast-json-patch o rfc6902. Stesso diff, due output.
Il JSON diff tratta null e key mancanti allo stesso modo?
No. {"a":null} e {} sono diversi — il primo ha un null esplicito, il secondo non ha la key. I sistemi reali si comportano diversamente nei due casi; questo tool li mantiene distinti.
Come vengono confrontati gli array — per indice o per key?
Per indice (Sequenziale) per impostazione predefinita. Passa a 'Corrispondenza per key' e fornisci un campo key (comunemente id) per allineare gli elementi indipendentemente dall'ordine. Utile per env K8s, voci di package-lock o qualsiasi lista che è logicamente un insieme.
Posso esportare il diff come JSON Patch RFC 6902?
Sì. Il tab JSON Patch produce un array di operazioni RFC 6902 valido. Se sono impostati Ignora percorsi, il patch è filtrato (il tab mostra '(filtrato: esclude N percorsi ignorati)') e non ricostruirà esattamente gli originali. Cancella Ignora percorsi per un patch completo.
JSON Patch è uguale a JSON Merge Patch (RFC 7396)?
No. RFC 6902 (JSON Patch) è un array ordinato di operazioni — esplicito e reversibile. RFC 7396 (Merge Patch) è un singolo documento di merge — più semplice ma non può rappresentare la rimozione in modo diverso dall'impostare null. JSON Diff produce output RFC 6902.
Come confronto due grandi file JSON (>10 MB)?
File oltre ~5 MB superano la memoria pratica del browser. La modalità live si disabilita a 200 KB; per file di diversi megabyte, usa jq da riga di comando o fast-json-patch in Node.
Il tool invia il mio JSON a un server?
No. Tutto il confronto viene eseguito localmente nel browser. Gli input non vengono mai scritti su disco, rete, localStorage o parametri URL. Aggiornare la pagina li cancella. Il pulsante Share Link scrive solo la configurazione (modalità Array, Ignora percorsi) — mai i dati.
Perché 42 è diverso da "42" nel diff?
JSON Diff è type-strict: il numero 42 e la stringa "42" non sono uguali. Questo rileva la deriva della serializzazione del backend (alcuni endpoint restituiscono ID numerici, altri stringhe) — il diff lo etichetta come modifica di 'tipo'.
Posso fare il diff di JSON con commenti (JSONC) o virgole finali?
Il JSON standard (RFC 8259) non consente commenti o virgole finali. Questo tool usa JSON.parse nativo, che li rifiuta entrambi. Rimuovi prima i commenti usando JSON Formatter.
Come confronto array annidati di oggetti per una key come id?
Imposta la modalità Array su 'Corrispondenza per key' e inserisci id. Il diff si allinea per valori di id. La v1 applica lo stesso campo key a ogni profondità di array; gli array interni senza quel campo tornano al sequenziale e mostrano un avviso.
Il diff gestisce la precisione floating-point (0.1 + 0.2)?
Sì, con la tolleranza numerica. Il valore predefinito è 0 con Object.is — quindi -0 e +0 vengono segnalati come diversi. Imposta la tolleranza su un epsilon piccolo (es. 1e-9) e 0.1 + 0.2 risulterà uguale a 0.3. La tolleranza si applica solo alle foglie numeriche.

Strumenti correlati

Vedi tutti gli strumenti →