Skip to content

Tekst vergelijken & Diff

Vergelijk direct twee teksten in de browser. Naast-elkaar weergave met inline woordmarkering, unified-diff export, hoofdletters / spaties / lege regels negeren. 100 % in de browser — geen upload, je tekst blijft op je apparaat.

Geen tracking Draait in je browser Gratis
Alle vergelijking draait lokaal in je browser. Je tekst verlaat dit apparaat niet.
Negeer-opties
Beoordeeld op pariteit met `diff -u` output, correctheid van intra-line LCS en toegankelijkheid (ARIA-rollen, screenreader-aankondigingen van wijzigingen, RTL/LTR-afhandeling). — Go Tools Text Tooling Team · May 21, 2026

Wat is Text Diff?

Text diff is een gestructureerde vergelijking van twee tekstdocumenten die de kleinste set invoegingen en verwijderingen vindt die het ene in het andere transformeert. De output maakt de wijziging zichtbaar: groen voor toegevoegde regels, rood voor verwijderde, naast elkaar of in unified-patch vorm (het `---/+++/@@`-formaat dat door `git`, GitHub en het Unix-`patch`-commando wordt gebruikt).

Onder de motorkap is elke moderne diff een Longest Common Subsequence (LCS) algoritme. Eugene Myers' paper uit 1986 over O((N+M)D) is de canonieke efficiënte implementatie; klassiek dynamisch programmeren (hier gebruikt, met trimming van gemeenschappelijke prefixen/suffixen) is eenvoudiger en werkt perfect voor typische web-inputs. Nadat regels uitgelijnd zijn, gaan naburige verwijder + toevoeg paren door een tweede token-niveau LCS, zodat de renderer alleen de woorden kan markeren die daadwerkelijk binnen een regel veranderd zijn — wat reviewers intra-line of woord-niveau diff noemen.

Waarom niet gewoon teken-voor-teken vergelijken? Omdat bewerkingen zelden plat zijn: één regel invoegen in het midden van een bestand van 200 regels verschuift elke regel daaronder. Een naïeve `===` zou alle 199 regels als verschillend bestempelen. LCS vertelt je de waarheid: één regel toegevoegd, 199 onveranderd.

Dit tool draait de hele vergelijking in je browser. Geen upload, geen tijdelijk bestand, geen log. Veilig voor propriëtaire code, redlined contracten, privé logs — alles wat je niet in een server van derden wilt plakken. Wil je JSON diffen? Gebruik de structurele JSON Diff zodat sleutelvolgorde en whitespace geen ruis meer zijn. Twee configs in YAML of CSV vergelijken? Converteer eerst met YAML to JSON of JSON to CSV, en diff dan met het juiste tool voor het formaat.

// Two strings that look 'mostly the same' but a naïve check disagrees
const a = 'hello world';
const b = 'hello, world!';

// Character equality
a === b; // false — but only 3 characters actually changed.

// LCS-style diff (this tool, at line + word granularity)
// → 1 line modified, inline highlight: 'hello[, ]world[!]'
// → unified patch:
//   --- original
//   +++ modified
//   @@ -1 +1 @@
//   -hello world
//   +hello, world!

Belangrijkste functies

Side-by-Side + Unified

Schakel tussen de visuele twee-koloms weergave (voor menselijke review) en het canonieke unified-diff patchformaat (voor `git apply`, code-review tools, bugrapporten).

Inline woord-niveau markering

Wanneer twee regels als gewijzigd worden gekoppeld, dragen alleen de gewijzigde tokens een gekleurde achtergrond. Je oog vindt de bewerking direct in plaats van 80 tekens af te scannen.

Hoofdletters / whitespace / lege regels negeren

Vier onafhankelijke schakelaars: hoofdletters, alle whitespace, alleen trailing whitespace, lege regels. Repliceert `git diff -i -w -b` met een paar klikken.

Unified diff export

Kopieer een schone `---/+++/@@`-patch met drie regels context. Past direct in een PR-opmerking, een bugrapport of `patch -p1`.

100 % browsergebaseerd

Inputs verlaten nooit je apparaat. Geen upload, geen analytics op tekst. Werkt offline zodra de pagina is geladen. Veilig voor propriëtaire code en vertrouwelijke proza.

Unicode + RTL bewust

Splitst tokens op Unicode-woordgrenzen. Arabisch, Hebreeuws, CJK-inhoud vergelijkt schoon; regeleindevarianten (CRLF, LF, CR) worden allemaal genormaliseerd.

Voorbeelden

Code review — één variabele hernoemd

function getUser(id) {
  const u = db.users.find(x => x.id === id);
  return u;
}
function getUser(userId) {
  const u = db.users.find(x => x.id === userId);
  return u;
}

De naast-elkaar weergave markeert elke regel met de hernoeming, terwijl de inline woord-diff onveranderde tokens dempt — reviewers zien direct welke identifier is gewijzigd.

Contractwijziging — één clausule toegevoegd

1. The service is provided as-is.
2. Either party may terminate with 30 days notice.
3. Disputes are resolved in California courts.
1. The service is provided as-is.
2. Either party may terminate with 30 days notice.
2a. Termination notice must be in writing.
3. Disputes are resolved in California courts.

Een enkele ingevoegde clausule (regel 2a) is het enige verschil. De omliggende context blijft schoon — handig voor het redlinen van contracten of beleidsdocumenten.

Loganalyse — request-timing gewijzigd

GET /api/users 200 14ms
POST /api/orders 201 88ms
GET /api/orders/42 200 21ms
GET /api/users 200 14ms
POST /api/orders 201 4200ms
GET /api/orders/42 500 21ms

Twee regels veranderen. De inline markering toont 88ms → 4200ms latency drift en 200 → 500 statuscode. Standaard werkwijze voor een incident-tijdlijn.

Trailing whitespace — 'Trailing negeren' inschakelen

  margin: 0;  
  padding: 0;
  border: none;
  margin: 0;
  padding: 0;
  border: none;

Zonder de optie meldt regel 1 een verschil (trailing spaties). Schakel 'Trailing spaties / tabs negeren' in en de diff gaat naar nul — dezelfde truc als `git diff -b`.

Zo werkt het

  1. 1

    Plak beide versies

    Originele tekst links, gewijzigde tekst rechts. Live diff rendert tijdens het typen; grote inputs (>200 KB gecombineerd) schakelen over naar een handmatige Diff-knop.

  2. 2

    Schakel de benodigde negeer-opties in

    Hoofdletters negeren, alle whitespace negeren, trailing spaties negeren of lege regels negeren — elk onafhankelijk, behouden tussen bezoeken.

  3. 3

    Lees de diff of pak de patch

    Side-by-Side voor menselijke review, Unified voor het `---/+++/@@`-patchformaat. Unified diff kopiëren stuurt een schone patch naar je klembord voor code-review of `patch -p1`.

Veelvoorkomende diff-valkuilen

Hele bestand 'gewijzigd' na Windows-vs-Unix kopie

Als je plakt vanuit Notepad op Windows in een Unix-bewerkt origineel, toont elke regel \r-verschillen. Schakel 'Trailing spaties / tabs negeren' in om de CR-tekens te dempen.

✗ Fout
Diff: 200 modifications (all because of trailing \r)
✓ Correct
Ignore trailing spaces / tabs → 2 real changes

Diff schreeuwt om indentatie

Herformatteren van tabs ↔ spaties laat regel-voor-regel diffs ontploffen. 'Alle whitespace negeren' vouwt de diff samen tot de werkelijke semantische wijzigingen.

✗ Fout
Diff: 87 modifications (all are indent changes)
✓ Correct
Ignore all whitespace → 4 actual changes

Identieke alinea's gemarkeerd vanwege één lege regel

Een enkele lege regel toevoegen of verwijderen in proza kan een hele regio verkeerd uitlijnen. 'Lege regels negeren' lost dit op zonder de inhoud aan te raken.

✗ Fout
Diff: paragraph 2 'completely changed' (one blank line moved)
✓ Correct
Ignore blank lines → no changes in paragraph 2

Diff zegt 'identiek' maar de bestanden zijn anders

Bijna altijd een hoofdletter- of whitespace-negeer optie die nog aan staat van een vorige sessie. Open het Negeer-opties paneel — elke schakelaar is daar zichtbaar. Zet ze allemaal uit als je een byte-strikte vergelijking wilt.

✗ Fout
0 differences shown, but `cmp` says the files differ
✓ Correct
Disable all Ignore options → real diff appears

Geplakte JSON lijkt 'helemaal veranderd'

Text diff behandelt sleutelvolgorde als significant; JSON niet. Voor JSON-payloads gebruik je het toegewijde JSON Diff tool — het negeert sleutelvolgorde en respecteert typestriktheid.

✗ Fout
Text diff on JSON: 100% of lines changed (just a key reorder)
✓ Correct
<a href="/nl/tools/json-diff">JSON Diff</a>: 0 differences

Diff-truncatie waarschuwing genegeerd

Boven 5.000 regels per kant wordt de input afgekapt. Als de waarschuwing verschijnt, schakel dan naar command-line `diff -u file1 file2` of `git diff --no-index` — beide streamen en behandelen gigabytes.

✗ Fout
Pasted a 20,000-line log — only first 5,000 lines diffed
✓ Correct
`diff -u a.log b.log` in terminal handles full file

Veelvoorkomende toepassingen

Code-review snippet
Plak twee versies van een functie in de vakken om een hernoeming, een verwijderde branch of een nieuwe guard-clausule in één oogopslag te zien. Inline woordmarkering is sneller dan het scannen van de GitHub-diff voor een eenregelige wijziging.
Contract / beleids-redline
Plak het contract van gisteren tegen de revisie van vandaag. Ingevoegde clausules springen eruit; onveranderde alinea's vallen terug naar grijs. Exporteer de unified-patch voor het juridische beoordelingsspoor.
Log-tijdlijn analyse
Vergelijk een pre-incident logslice van een SRE met de slice tijdens het incident. Latency, statuscode en frequentiedrift komen direct naar boven zonder `awk`.
Proza / concept-revisie
Plak een concept en de versie van je editor. Inline woord-diff toont precies welke zinnen zijn herschreven — onmisbaar om wijzigingen één voor één te accepteren of af te wijzen.
Vertaal-review
Diff een oude vertaling tegen een hervertaling om te bevestigen dat de nieuwe versie betekenis, structuur en placeholders bewaart. Schakel 'Trailing spaties negeren' in om ruis te dempen die vertalers vaak introduceren.
Config / .env bestandsaudit
Vergelijk twee `.env`, `docker-compose.yaml` of shell rc-bestanden. Met 'Lege regels negeren' aan focust de diff op functionele verschillen in plaats van opmaakruis.

Technische details

LCS met prefix/suffix trimming
Gemeenschappelijke leidende en eindigende regels worden gestript voordat de dynamisch geprogrammeerde LCS draait. Een 'twee 2.000-regel configs met één gewijzigde regel'-diff valt samen tot een 1×1 DP-tabel en rendert in onder een milliseconde.
Token-niveau intra-line diff
Aangrenzende verwijder + toevoeg hunks worden gekoppeld en getokeniseerd via Unicode woord-/niet-woord-/whitespace-reeksen. Een tweede LCS-pass produceert de groen/rode token-spans die gewijzigde regels leesbaar maken.
Unified diff = git/patch compatibel
De output volgt het `---/+++/@@ -L,C +L,C @@`-formaat zoals gedefinieerd voor GNU patch en gebruikt door Git, GitHub en elk code-review tool. Toepassen met `pbpaste | patch -p0`.
Input-cap bij 5.000 regels per kant
Boven de cap wordt de diff afgekapt en gewaarschuwd. Voor inputs van meerdere megabytes gebruik je command-line `diff -u` of `git diff --no-index` — die streamen en behandelen gigabytes.

Best practices

Kies de negeer-opties vóór het lezen
Trailing-space, CRLF en hoofdletter-ruis overstemmen het signaal. Schakel eerst de juiste opties in; de diff is veel makkelijker te lezen en je traint jezelf niet om langs 'nep'-wijzigingen te scannen.
Unified voor delen, Side-by-Side voor reviewen
Visuele kolommen zijn voor jouw ogen. Unified patches zijn voor andermans terminals. Een gekopieerde unified diff valt zonder vertaling in een Slack-bericht, een Jira-opmerking of `patch -p1`.
Sanity-check met overeenkomstpercentage
Als twee bestanden 'bijna hetzelfde' zijn maar de overeenkomst is 30 %, heb je een regeleinde- of whitespace-probleem. Schakel 'Alle whitespace negeren' in en hercheck voordat je de diff leest.

Veelgestelde vragen

Wordt de tekst die ik plak naar jullie server gestuurd?
Nee. Elke vergelijking draait in JavaScript binnen je browser. Je tekst wordt niet geüpload, gelogd, op schijf opgeslagen of naar derden gestuurd. Alleen je UI-voorkeuren (weergavemodus en negeer-opties) worden opgeslagen in localStorage zodat de pagina ze bij het volgende bezoek onthoudt — nooit de tekst. Je kunt dit controleren via DevTools → Network: nul requests bij een klik op Diff.
Wat is het verschil tussen text diff en JSON diff?
Text diff vergelijkt regel voor regel — perfect voor proza, code, logs, contracten, configuratiebestanden. JSON Diff begrijpt het datamodel van JSON: sleutelvolgorde is irrelevant, typen zijn strikt, arrays kunnen op sleutel worden gematcht. Als je JSON in een text diff plakt, worden sleutelherschikkingen en spatieverschillen als wijzigingen gemarkeerd; JSON Diff negeert ze. Gebruik text diff voor ongestructureerde inhoud, JSON Diff voor API-responses en config-payloads.
Hoe negeer ik spaties, hoofdletters of lege regels?
Klik op het paneel 'Negeer-opties' boven de diff. 'Hoofdletters negeren' maakt A en a gelijk. 'Alle whitespace negeren' vouwt elke spatie, tab en newline samen voor de vergelijking. 'Trailing spaties / tabs negeren' verwijdert alleen whitespace aan het einde van de regel — het standaardgedrag van `git diff -b`. 'Lege regels negeren' laat lege regels vallen vóór de diff. Elke optie is onafhankelijk en blijft behouden tussen bezoeken.
Wat is een unified diff (en wanneer kopieer ik die)?
Een unified diff is het `---/+++/@@`-tekstformaat dat door `patch`, `git apply`, GitHub-PR's en de meeste code-review tools wordt gebruikt. Klik op Unified diff kopiëren om een patch met drie regels context rond elke wijziging te krijgen — plak hem in een bugrapport, code-review opmerking of een `patch -p1`-commando en hij past schoon toe. Side-by-side is voor mensen, unified diff is voor machines (en code reviewers die als machines denken).
Waarom toont de diff hele regels als gewijzigd terwijl ik maar één woord heb bewerkt?
Dat doet hij niet — kijk beter. De hele regel is gemarkeerd omdat er iets op is veranderd, maar binnen de markering dragen alleen de gewijzigde tokens de heldere achtergrond (groen voor toegevoegd, rood doorgestreept voor verwijderd). Dit is intra-line woord-diff: de regelcontext blijft leesbaar terwijl je oog op de exacte bewerking landt. Als twee opeenvolgende regels beide zijn gewijzigd, tonen beide inline markering.
Hoe worden CRLF vs LF regeleindes afgehandeld?
Beide worden herkend. De diff splitst op \r\n, \n en losse \r, dus Windows CRLF, Unix LF en oude Mac CR-tekst sluiten correct aan. Wil je regeleindewijzigingen specifiek markeren, laat dan 'Trailing spaties / tabs negeren' uit — \r verschijnt dan als trailing teken. Om regeleinde-ruis volledig te elimineren, schakel je 'Alle whitespace negeren' in.
Hoe groot mogen de twee inputs zijn?
De diff draait op de hoofdthread, dus praktische grenzen liggen rond 5.000 regels of 1 MB per kant; daarboven knippen we en tonen een waarschuwing. Live diff schakelt uit boven 200 KB gecombineerd en schakelt over naar een handmatige Diff-knop. Voor bestanden van meerdere megabytes gebruik je command-line `diff -u` of `git diff --no-index` — die streamen en behandelen gigabytes.
Wat met code diffen? Kent het mijn taal?
De diff is taalonafhankelijk: hij ziet regels en tokens, geen syntax. Dat is een voordeel voor review-snippets, configwijzigingen en geplakte patches. Wil je een semantische code-diff (hernoemde functie over bestanden heen, AST-niveau), gebruik dan git, de GitHub-PR-weergave of een toegewijd structureel diff-tool. Voor 90 % van de code-review situaties — een functie bekijken, twee snippets vergelijken — is regel + woord diff precies wat je wilt.
Waarom verschijnt een enkele bewerking soms als een verwijderde regel plus een toegevoegde regel?
Als er te veel van een regel is veranderd voor zinvolle woordmarkering, rapporteert de diff het als aparte verwijder + toevoeg regels zodat de structuur schoon blijft. Dezelfde heuristiek geeft leesbare output voor herschreven proza en voor codeblokken die zijn herschreven in plaats van bewerkt. Schakel over naar Unified weergave om het klassieke `-`/`+`-paarformaat te zien dat in patches wordt gebruikt.
Hoe wordt het overeenkomstpercentage berekend?
Het is het aantal onveranderde regels (na toepassing van negeer-opties) gedeeld door de grootste van de twee regelaantallen, begrensd op 100 %. Twee identieke inputs zijn 100 %. Eén nieuwe regel toevoegen aan een bestand van 100 regels geeft 99 %. Elke regel vervangen is 0 %. Handig om snel in te schatten of het een kleine wijziging of een complete herschrijving is, voordat je de diff leest.
Kan ik een diff delen met een collega?
Ja, op twee manieren. (1) Klik Unified diff kopiëren en plak de patch in chat, Slack of een PR-opmerking — iedereen met een terminal kan `patch < clip` toepassen. (2) Maak een screenshot van het naast-elkaar paneel voor visuele review. We bieden bewust geen 'Delen via URL'-knop: dat zou je tekst moeten uploaden, wat we niet doen.
Werkt de diff met rechts-naar-links talen zoals Arabisch of Hebreeuws?
Ja voor de tekstinhoud — regels en tokens zijn Unicode-bewust. De interface gebruikt logische CSS-richtingen, dus in RTL-locales draaien de gutter en regelkolommen vanzelf om. Binnen een diff-cel volgt de tekstrichting de inhoud, dus Arabische en Hebreeuwse tekenreeksen renderen correct terwijl de +/--markers tegen de gutter uitgelijnd blijven.

Gerelateerde tools

Alle tools bekijken →