Diff Checker

Il diff checker confronta due porzioni di testo e mostra esattamente quali righe differiscono. Incolla l'originale (la versione 'prima') nella casella di testo a sinistra e la modificata (la versione 'dopo') a destra; lo strumento esegue un diff basato su LCS ed evidenzia ogni differenza in pochi millisecondi.

Le righe aggiunte appaiono in verde, quelle rimosse in rosso, mentre le righe modificate mostrano un'evidenziazione a livello di carattere sulla sottostringa effettivamente cambiata. Una riga di riepilogo in alto riporta il conteggio delle righe aggiunte, rimosse e modificate insieme a una percentuale di somiglianza.

Usalo per qualsiasi confronto in solo testo:

• codice sorgente
• configurazioni JSON
• manifest YAML
• esportazioni CSV
• file di log
• bozze in Markdown
• prosa semplice

Lo strumento gestisce input UTF-8 fino a diversi megabyte per lato senza bloccarsi.

Soprattutto: ogni byte di calcolo viene eseguito localmente nel tuo browser. Nulla viene inviato a un server, nulla viene registrato, nulla lascia il tuo dispositivo — sicuro per codice proprietario, documenti interni e dati riservati.

Confrontare due testi richiede tre rapidi passaggi:

• Passaggio 1: Incolla il testo originale nella casella di sinistra. Questa è la versione 'prima' — il file com'era prima delle modifiche, la bozza originale, la configurazione precedente. Usa Ctrl+A e poi Ctrl+C da qualsiasi editor di testo o browser per copiare il testo, quindi Ctrl+V nel diff checker.
• Passaggio 2: Incolla il testo modificato nella casella di destra. Questa è la versione 'dopo' — il file modificato, la nuova bozza, la configurazione aggiornata. Il diff viene calcolato automaticamente non appena entrambi i lati contengono del testo.
• Passaggio 3: Leggi il risultato. Le righe verdi sono aggiunte presenti a destra ma non a sinistra; le righe rosse sono rimozioni presenti a sinistra ma non a destra; le righe con evidenziazione a livello di carattere sono 'modificate' (una coppia di rimozione + aggiunta su contenuto simile).

Il riepilogo in alto offre una panoramica generale: conteggio delle aggiunte, conteggio delle rimozioni e percentuale di somiglianza da 0% (nessuna sovrapposizione) a 100% (identici).

Attiva 'ignora spazi bianchi' se le uniche modifiche riguardano la formattazione; attiva 'ignora maiuscole/minuscole' se non ti interessa la distinzione tra Maiuscole e minuscole.

Gli strumenti di diff funzionano a tre livelli di granularità: riga, parola o carattere.

• Riga per riga è il valore predefinito universale per codice e configurazione: ogni riga viene trattata come un'unità e il diff identifica quali intere righe sono state aggiunte, rimosse o sostanzialmente modificate. Questo è ciò che mostrano GNU diff, git diff, le PR di GitHub e le viste diff degli IDE.
• Parola per parola (talvolta chiamato 'word diff') divide il testo in base agli spazi bianchi — migliore per la prosa dove le modifiche avvengono spesso all'interno delle frasi.
• Carattere per carattere è la granularità più fine, utilizzata internamente dalla maggior parte degli strumenti di diff per evidenziare l'esatta sottostringa che differisce all'interno di una riga modificata.

Lo strumento sopra mostra il diff di riga come vista principale e il diff di carattere come evidenziazione sulle righe modificate — lo stesso approccio a due livelli utilizzato da VS Code, JetBrains e GitHub.

Usa il diff di riga per la revisione del codice, il diff di parola per la modifica di testi in prosa e il diff di carattere solo per brevi confronti (singole frasi, identificatori, URL).

Il codice sorgente è il caso d'uso più comune per il diff: ogni revisione del codice, ogni PR e ogni commit di git comporta il confronto di codice.

Il diff checker gestisce qualsiasi linguaggio di programmazione perché l'algoritmo LCS è indipendente dal linguaggio: JavaScript, TypeScript, Python, Go, Rust, Java, Kotlin, Swift, C, C++, C#, PHP, Ruby, Scala, Elixir, Clojure, script di shell, Dockerfiles, Terraform HCL, SQL — funzionano tutti allo stesso modo.

Migliore pratica per i diff di codice: formatta entrambi i lati con lo stesso formattatore di codice (Prettier per JS/TS, Black per Python, gofmt per Go, rustfmt per Rust) prima di incollare, in modo che le differenze di spazi bianchi e stile non inquinino il vero diff semantico. Se non puoi riformattare, usa l'opzione 'ignora spazi bianchi' per saltare le differenze di spazi bianchi iniziali/finali.

Per confrontare codici di linguaggi diversi (ad esempio confrontando un'implementazione in Python con una versione in Go), il diff di riga funziona comunque ma la percentuale di somiglianza sarà fuorviante: l'unità significativa è la somiglianza strutturale, non la sovrapposizione delle righe.

Il diff JSON è uno dei casi d'uso più richiesti: confrontare risposte API, file di configurazione, file package.json ed esportazioni di dati strutturati.

Passaggio preliminare importante: formatta entrambi i lati in modo identico. Applica una formattazione leggibile (pretty-print) con la stessa indentazione (in genere 2 o 4 spazi) e ordina le chiavi degli oggetti in ordine alfabetico. Senza normalizzazione, un documento JSON strutturalmente identico può produrre un diff estremamente rumoroso solo perché le chiavi sono in un ordine diverso.

Strumenti per la normalizzazione:

• jq con il flag --sort-keys
• json.dumps di Python con sort_keys=True
• jsonformatter.org

Per un diff JSON semanticamente consapevole (in cui {a:1, b:2} e {b:2, a:1} sono uguali), strumenti dedicati come json-diff (npm), jq o JSON Patch RFC 6902 producono risultati migliori rispetto al diff di riga.

Lo strumento di diff di riga sopra funziona bene per il JSON quando entrambi i lati sono pre-normalizzati; se hai regolarmente bisogno di un diff JSON semantico, prendi in considerazione una libreria compatibile con JSON nel tuo stack.

YAML e CSV sono formati orientati alle righe che si confrontano in modo pulito con strumenti basati su righe, solitamente con meno rumore rispetto al JSON perché YAML non ha parentesi graffe e CSV ha una struttura di righe coerente.

Suggerimenti per YAML diff: assicurati che entrambi i lati utilizzino la stessa indentazione (2 o 4 spazi fanno la differenza; in YAML gli spazi bianchi sono significativi), la stessa convenzione di ordinamento delle chiavi e lo stesso stile di virgolette per le stringhe. Per i manifest di Kubernetes, i file Docker Compose e i YAML dei flussi di lavoro CI, il diff di riga sopra è lo strumento standard utilizzato in ogni revisione del codice.

Suggerimenti per CSV diff: assicurati che entrambi i file utilizzino lo stesso delimitatore (virgola, punto e virgola, tabulazione), le stesse terminazioni di riga (LF vs CRLF — molti CSV di Excel usano CRLF), lo stesso ordine delle colonne e intestazioni corrispondenti.

Per CSV di grandi dimensioni (>10.000 righe), strumenti specializzati come csvdiff (Aswinkarthik) o daff (paulfitz) producono diff strutturati che mostrano quale riga e colonna sono cambiate; per file più piccoli il diff di riga sopra è veloce e semplice.

Tutti i moderni strumenti di diff si affidano alla famiglia di algoritmi LCS (Longest Common Subsequence).

L'algoritmo di diff originale è stato pubblicato da James Hunt e Doug McIlroy ai Bell Labs nel 1976 — lo stesso articolo che ha generato il comando 'diff' di Unix ancora oggi in uso. Nel 1986, Eugene Myers ha pubblicato 'An O(ND) Difference Algorithm and Its Variations', che ha ottimizzato l'LCS per il caso comune di piccole differenze in grandi input.

L'algoritmo di Myers viene eseguito in tempo O((N+M)D) dove N+M è la dimensione totale dell'input e D è il numero di modifiche — molto più veloce del diff oracolare O(N×M) per i tipici diff del mondo reale (dove D è piccolo rispetto a N+M). GNU diff, git diff, libxdiff (utilizzato da Mercurial, Subversion, GitHub) implementano tutti Myers o le varianti strettamente correlate 'patience diff' e 'histogram diff'.

Il diff checker sopra utilizza un'implementazione LCS in JavaScript ottimizzata per le prestazioni del browser — abbastanza veloce per input fino a diversi megabyte per lato.

Esistono due modi principali per visualizzare un diff: affiancato (split view) e unificato.

Affiancato posiziona la versione originale e quella modificata in due colonne con le modifiche allineate orizzontalmente — più facile da leggere per un essere umano perché puoi vedere entrambe le versioni contemporaneamente e il raggruppamento visivo rende la struttura ovvia. Questa è la visualizzazione predefinita negli IDE (VS Code, IntelliJ), nelle PR di GitHub (in modalità 'split') e nella maggior parte degli strumenti di diff online.

Unified diff accumula le righe rimosse e aggiunte in un'unica colonna con prefissi '-' e '+' più 3 righe di contesto invariato sopra e sotto — più compatto, programmabile (è il formato di file patch consumato da 'git apply' e 'patch') e predefinito negli strumenti da riga di comando e nella revisione del codice basata su e-mail (mailing list del kernel Linux, ecc.).

Scegli la modalità affiancata per la revisione visiva di modifiche da piccole a medie; scegli quella unificata per la visualizzazione compatta di grandi riscritture, per la copia come file patch o per la condivisione in contesti di solo testo (chat, e-mail, terminale).

Il confronto di documenti copre una vasta gamma di casi: tracciare ciò che un editor ha modificato in una bozza, confrontare due versioni di un contratto, verificare cosa è stato parafrasato rispetto a cosa è stato copiato (rilevamento del plagio leggero) o controllare la deriva di traduzione.

Usa il diff checker per qualsiasi documento in solo testo. Per diversi formati sorgente:

• Per file Microsoft Word .docx, esporta prima in testo semplice (File > Salva con nome > Testo semplice in Word, o Formato > Testo semplice in LibreOffice). Perderai la formattazione (grassetto, corsivo, intestazioni) ma catturerai ogni modifica al testo.
• Per documenti PDF, usa prima un convertitore da PDF a testo (pdftotext da poppler-utils o strumenti basati su browser), quindi confronta il testo estratto.
• Per Google Docs, usa la Cronologia delle versioni integrata (File > Cronologia versioni > Visualizza cronologia versioni) che mostra nativamente i diff con tracciamento degli autori.

Per prosa di grande formato in cui le interruzioni di riga sono arbitrarie, considera gli strumenti di diff a livello di parola (diff --word-diff in git) — ignorano l'andamento a capo delle righe e fanno emergere le reali modifiche a livello di parola.

La privacy è importante quando si confrontano codice proprietario, documentazione interna, registri finanziari, dati dei clienti o qualsiasi testo riservato. Molti strumenti di diff online caricano il testo di input sul proprio server per l'elaborazione — comodo ma un vero rischio per contenuti sensibili.

Il diff checker su questa pagina è completamente lato client: l'algoritmo LCS viene eseguito in JavaScript all'interno del tuo browser, nessuna chiamata fetch() lascia mai il tuo dispositivo, nessun registro viene creato su alcun server. Verificalo tu stesso aprendo DevTools > scheda Network e incollando il testo: vedrai zero richieste in uscita.

Per la massima privacy su contenuti altamente sensibili, usa uno strumento locale che non tocchi mai la rete:

• GNU diff (preinstallato su Linux/macOS)
• git diff (qualsiasi repository)
• Diff integrato di VS Code
• Diff degli IDE JetBrains
• Beyond Compare

Per confronti occasionali di testi meno sensibili, uno strumento verificato basato su browser come quello sopra offre la comodità di uno strumento web unita alla privacy di uno locale.

Per gli sviluppatori, il diff è un'infrastruttura quotidiana — code review, revisione di PR, risoluzione dei conflitti di merge, confronto delle configurazioni tra ambienti, debug delle regressioni del tipo 'cosa è cambiato'.

Usa git diff per le modifiche tracciate (git diff, git diff --staged, git diff main..feature, git diff HEAD~3); usa il diff checker online sopra per confronti ad hoc (qualcuno incolla uno snippet su Slack, confronti il dump di una variabile d'ambiente da staging a prod, controlli la configurazione locale di un collega rispetto alla tua).

Per la risoluzione dei conflitti di merge, gli strumenti di diff a tre vie (kdiff3, p4merge, vista a tre vie integrata di VS Code) superano il diff a due vie perché mostrano l'antenato comune oltre a entrambi i lati.

Per la revisione del codice su larga scala, le PR di GitHub, i MR di GitLab e Gerrit utilizzano tutti lo stesso diff LCS basato su righe sotto il cofano — ciò che vedi in una PR è lo stesso algoritmo che puoi eseguire localmente con git diff o incollare nello strumento online sopra. Il diff è riproducibile tra vari strumenti: gli stessi input producono sempre lo stesso diff.

Entrambi producono diff basati su LCS matematicamente equivalenti — l'algoritmo sottostante è lo stesso.

Usa git diff quando:

• hai file in un repository git
• vuoi confrontare commit/branch/modifiche in staging
• devi creare uno script per il diff (controlli CI, hook di pre-commit)
• hai bisogno di un confronto basato sulla cronologia (git log, git blame)
• oppure stai producendo un file patch (git format-patch)

Usa un diff checker online quando:

• hai testo grezzo che non si trova in un repository (uno snippet da una chat, una risposta API, un dump di configurazione)
• desideri una rapida visualizzazione affiancata senza configurare un repository
• stai confrontando sistemi in cui git non è disponibile (qualcuno su un Chromebook, una riunione di revisione del codice)
• oppure il contenuto è sensibile e desideri uno strumento verificato solo per browser senza chiamate di rete

Entrambi gli strumenti appartengono al kit di strumenti di uno sviluppatore; nessuno sostituisce l'altro. Le funzionalità chiave dello strumento online sono l'assenza di configurazione e la visualizzazione affiancata; le funzionalità chiave di git sono la consapevolezza della cronologia e l'integrazione nell'ecosistema.