Skip to content

Gratis regex-tester — patronen testen & debuggen online

Test reguliere expressies direct tegen elke tekst. Live highlighting van overeenkomsten, vastlegroepen, voorvertoning van vervangingen, splitsen en patroonuitleg. JavaScript-flavor regex, 100% privé, gratis, geen account.

Geen tracking Draait in je browser Gratis
Alle testen draaien lokaal in je browser. Je patroon en tekst verlaten dit apparaat nooit.
Flags
    Gehighlighte overeenkomsten
    Overeenkomsten & vastlegroepen
    Beoordeeld op ECMA-262-trouw, correctheid van vastlegroepen (met en zonder de /d-flag), pariteit van vervangingssjablonen met String.prototype.replace, ReDoS-weerstand via wall-clock-budgettering, en toegankelijkheid (ARIA-rollen, screenreader-aankondigingen van overeenkomsten, RTL/LTR-verwerking). — Go Tools Text Tooling Team · May 21, 2026

    Wat is een regex-tester?

    Een regex-tester (reguliere-expressie-tester) is een tool waarmee je een regex-patroon schrijft, een stuk testtekst plakt en precies ziet wat het patroon matcht — met vastlegroepen, vervangingsvoorvertoning en een flag-uitsplitsing — zonder code te hercompileren of een script te draaien. Voor developers verkort dat de loop van minuten naar milliseconden: tweak het patroon, kijk hoe de highlights bewegen, ship de regex met vertrouwen.

    Een reguliere expressie is een compacte taal om tekstpatronen te beschrijven. `\d+` matcht één of meer cijfers. `[A-Za-z_]\w*` matcht een typische identifier. `(?\d{4})-(?\d{2})-(?\d{2})` matcht een ISO-datum en benoemt elk deel. Reguliere expressies vormen de ruggengraat van zoeken-en-vervangen in elke code-editor, van validatie in elk formulier, van log-parsing in elke observability-stack, en van `grep`, `sed` en `awk` — de Unix-tools waarmee de helft van het internet draait. Ze zijn ook berucht lastig om correct te schrijven: een off-by-one quantifier of een ontbrekende escape kan de verkeerde substring matchen, een overeenkomst volledig missen of — in het ergste geval — catastrofale backtracking triggeren die een CPU-core gijzelt. Een goede regex-tester vangt elk van die faalmodi af voordat ze productie raken.

    Deze tester draait de native ECMA-262 RegExp-engine die in elke moderne browser zit — dezelfde engine die je aanroept vanuit JavaScript, TypeScript, Node.js, Deno of Bun. Dat betekent: vastlegroepen (genummerd en benoemd met `(?...)`), lookahead- en lookbehind-assertions (`(?=...)`, `(?!...)`, `(?<=...)`, `(?

    Wat de tester naast ruwe overeenkomsten oplevert: het paneel Overeenkomsten & vastlegroepen toont elke match met zijn [start, end) offsets en de waarde van elke vastleggroep — dezelfde informatie die je zou krijgen van `String.prototype.matchAll` met de /d-flag, maar uitgelegd voor visueel scannen. Het tabblad Vervangen toont een live-substitutievoorvertoning met ondersteuning voor het volledige $1- / $&- / $`- / $'- / $$- / $-sjabloon-alfabet — precies wat JavaScript's String.replace accepteert. Het tabblad Splitsen past String.split met de regex toe en toont elk deel. Het tabblad Uitleg tokeniseert het patroon en annoteert elk stuk in begrijpelijke taal, handig voor code-review, lesgeven en porten tussen dialecten.

    Over privacy: elke operatie is lokaal. Je patroon en je testtekst verlaten de pagina nooit — ze worden niet gelogd, niet naar een analytics-service gestuurd, niet op schijf opgeslagen. Alleen je UI-voorkeuren (actief tabblad + welke flags je meestal aan hebt) blijven in localStorage staan. Dat maakt deze tool veilig voor geredigeerde log-samples, proprietary patronen, interne config en patronen die hints bevatten over je dataschema. Vergeleken met server-backed testers als regex101 is het privacy- en latencyverhaal strikt beter; de trade-off is single-flavor support (alleen JavaScript).

    Ben je nieuw met regex, dan komt de dropdown Veelvoorkomende patronen met battle-tested starters: e-mailadres, URL, IPv4, UUID, hex-kleur, ISO-datum, Amerikaans telefoonnummer en een trim-trailing-whitespace-patroon. Laad er een, observeer de overeenkomsten met de geleverde voorbeeldtekst en muteer dan het patroon teken voor teken om te voelen hoe de engine reageert. Combineer dit met de Tekst-diff-tool als je voor/na van een regex-gestuurde opschoning wilt vergelijken, met JSON-formatter wanneer je invoer of verwachte output JSON is, of met URL-encoder wanneer de strings die je matcht URL-gecodeerd zijn.

    // The pattern you build in this tester drops straight into JavaScript.
// Example: extract every ISO date from a string with named groups.

const pattern = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/g;
const text = 'shipped 2026-05-21, scheduled 2026-06-30';

for (const m of text.matchAll(pattern)) {
  console.log(m.groups.year, m.groups.month, m.groups.day);
  // → 2026 05 21
  // → 2026 06 30
}

// Same regex, used in a replace with $<name> templates:
text.replace(pattern, '$<day>/$<month>/$<year>');
// → 'shipped 21/05/2026, scheduled 30/06/2026'

// With the /d flag, every match carries [start, end] indices
// per capture group — the Matches panel uses this to paint offsets.
const p2 = /(?<year>\d{4})-(?<month>\d{2})/gd;
const m = [...text.matchAll(p2)][0];
m.indices.groups.year; // [8, 12]

    Belangrijkste functies

    Live highlighting van overeenkomsten

    Elke overeenkomst in je testtekst licht op zodra je patroon parset. Afwisselende kleuren maken aangrenzende overeenkomsten visueel telbaar, en de count-badge boven het resultaat vertelt je het exacte totaal — geen Run-knop, geen debounce-vertraging boven de 200 ms.

    Zijpaneel voor vastlegroepen

    Het paneel Overeenkomsten & vastlegroepen rechts toont elke match als een kaart met zijn [start, end) offsets, de volledige match-tekst en elke positionele + benoemde vastleggroep erin. Benoemde groepen labelen zichzelf als $ zodat je de data op dezelfde manier leest als je ze in code consumeert.

    Live vervangingsvoorvertoning met $1 / $& / $

    Schakel over naar het tabblad Vervangen om je substitutie in realtime toegepast te zien. Het volledige ECMAScript-vervangingsalfabet werkt: $1..$N voor positioneel, $ voor benoemd, $& voor de hele overeenkomst, $` en $' voor prefix/suffix, $$ voor een letterlijke dollar. Naast elkaar geplaatste invoer- en outputpanelen met één-klik kopiëren.

    Splitsen op regex-grenzen

    Het tabblad Splitsen roept String.prototype.split aan met je regex en toont elk deel als een genummerde lijst. Lege delen worden gerenderd met een ⏎-glyph zodat je ziet hoe de engine aangrenzende scheidingstekens behandelde — handig voor het debuggen van CSV-achtige invoer-opschoning.

    Patroonuitleg (token voor token)

    Het tabblad Uitleg tokeniseert je patroon in chips gekleurd per klasse (escape / quantifier / character class / groep / anker / alternatie) en annoteert elke chip met een eenregelige beschrijving. Lees je eigen regex aan jezelf voor voordat je hem ship't; gebruik het voor code-review of lesgeven.

    ReDoS-veilig (wall-clock-time-out)

    Elke match-aanroep is in een budget van 250 milliseconden gewikkeld. Klassieke catastrofale-backtracking-vormen zoals `(a+)+`, `(a|aa)+b` en diep geneste quantifiers breken netjes af met een waarschuwing Patroon time-out — de pagina blijft responsief in plaats van het tabblad te blokkeren. Detectie zonder server-side sandbox.

    Bibliotheek met veelvoorkomende patronen

    Battle-tested starters voor de acht patronen waar developers het meest naar grijpen: e-mail, URL, IPv4, UUID v4, hex-kleur, ISO-datum, Amerikaans telefoonnummer en trim-trailing-whitespace. Elk laadt met een passende sample, zodat je de regex ziet werken voordat je hem aanpast.

    Permalink-delen (geen upload)

    Link kopiëren codeert patroon + flags + voorbeeldtekst in de URL-hash (#p=…&f=gim&t=…). Browsers verzenden URL-fragmenten nooit in requests, dus een gedeelde link reproduceert je state op de machine van de ontvanger zonder de servers van go-tools.org te raken. Selfcontained, audit-vriendelijk.

    100% privé, alleen in de browser

    Je regex en testtekst verlaten je apparaat nooit. Geen netwerkverzoeken, geen logging, geen analytics op wat je typt. Verifieer in DevTools → Netwerk: nul verzoeken terwijl je typt. Veilig voor proprietary patronen, geredigeerde logs en elke tekst die je niet in regex101 zou plakken.

    Uitgewerkte voorbeelden

    Alle e-mailadressen uit een alinea halen

    [a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}
    /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g

    Plak het patroon met de /g-flag aan, drop een alinea in de testtekst, en elk e-mailadres licht op in de gehighlighte weergave. Het paneel Overeenkomsten & vastlegroepen rechts toont elk adres met zijn [start, end) offsets — handig als je dezelfde regex doorgeeft aan grep, sed of een code-editor.

    Datumdelen vastleggen met benoemde groepen

    (?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})
    /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/g

    ECMA-262 benoemde groepen verschijnen in het rechterpaneel als $, $, $. Schakel over naar het tabblad Vervangen en probeer $/$/$ om ISO-datums in één keer naar DMY te herformatteren — dezelfde truc werkt in elke moderne JS replace-aanroep.

    Zoeken/vervangen met $1-terugverwijzingen

    (\w+) (\w+)
    Vervanging: $2, $1   →   Jack Doe → Doe, Jack

    Twee anonieme vastlegroepen, vervangingssjabloon $2, $1, en het tabblad Vervangen geeft je een live voorvertoning. $&, $`, $', $$ en $ worden allemaal ondersteund — precies het substitutie-alfabet uit de ECMAScript-spec, dus wat je eruit kopieert draait ongewijzigd in elke JS-engine.

    Achteraan staande witruimte regel voor regel wegstrippen

    [ \t]+$
    /[ \t]+$/gm

    Combineer de flags /g (global) en /m (multiline) zodat $ aan elk regeleinde verankert, niet alleen aan het einde van de invoer. Het tabblad Vervangen met een lege vervangingsvoorvertoning toont een schone diff: achteraan staande tabs en spaties verdwijnen, het proza blijft staan. Dezelfde regex met de flag /s (dotAll) uit houdt . binnen één regel.

    Catastrofale backtracking detecteren en overleven

    (a+)+b
    Testtekst: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac

    De geneste +-quantifiers vormen een klassiek ReDoS-patroon. In een naïeve tester loopt het tabblad vast. Hier slaat de wall-clock-bewaking na 250 ms aan, verschijnt de banner Patroon time-out en blijft de pagina responsief. Veranker het patroon, schakel over op niet-overlappende alternatie, of gebruik atomic-achtige idiomen — en test opnieuw.

    Een CSV-achtige regel splitsen op gemengde scheidingstekens

    [,;|]\s*
    alpha, beta; gamma | delta → ["alpha", "beta", "gamma", "delta"]

    Schakel over naar het tabblad Splitsen. Elke komma, puntkomma of pipe (gevolgd door optionele witruimte) wordt een deelgrens. Handig voor het opschonen van geplakte tag-lijsten, het normaliseren van gebruikersinvoer, of het voorbewerken van log-velden vóór een echte CSV-parser — zie CSV naar JSON wanneer de data echt RFC 4180 is.

    Zo gebruik je de regex-tester

    1. 1

      Typ je patroon tussen de slashes

      Drop een willekeurige ECMA-262 reguliere expressie in het /…/ veld. Foute patronen lichten rood op met een parser-melding; geldige patronen gaan door naar live-matching.

    2. 2

      Schakel de flags in die je nodig hebt

      g (global), i (hoofdletterongevoelig), m (multiline), s (dotAll), u (unicode), y (sticky), d (indices). Elke chip licht op als hij aan staat; de readout rechts van het patroon toont de canonieke literal.

    3. 3

      Plak je testtekst

      Overeenkomsten lichten in afwisselende kleuren op terwijl je typt. Het paneel Overeenkomsten & vastlegroepen rechts toont elke match met [start, end) offsets en de waarde van elke vastleggroep (benoemde groepen gelabeld $).

    4. 4

      Wissel van tabblad voor Vervangen, Splitsen of Uitleg

      Vervangen voorvertoont een substitutiesjabloon naast de invoer. Splitsen slicet op elke match-grens. Uitleg ontleedt het patroon token voor token met een platte beschrijving per element.

    5. 5

      Kopieer de literal of deel een permalink

      Kopieer /pattern/flags zet de canonieke regex-literal op je klembord voor direct gebruik in JavaScript / TypeScript / Node. Link kopiëren codeert de volledige state in een URL-hash (geen upload) zodat een collega het lokaal kan reproduceren.

    Veelvoorkomende regex-fouten

    /g-flag vergeten en maar één overeenkomst gekregen

    Zonder /g (of /y) stopt de engine na de eerste overeenkomst. De methoden match, matchAll, replace en split gedragen zich allemaal anders rond de global-flag. Schakel /g in en draai opnieuw; de teller boven de resultaten springt van 1 naar N.

    ✗ Fout 
    Patroon: /\d+/  →  '1 22 333' levert alleen ['1']
    ✓ Correct 
    Patroon: /\d+/g  →  '1 22 333' levert ['1', '22', '333']

    Hebzuchtige quantifier consumeerde te veel

    `.+` consumeert zoveel mogelijk, dus `<.+>` tegen ` en ` legt ` en ` vast, niet ``. Gebruik luie quantifiers (`.+?`), beperktere character classes (`[^>]+`), of veranker met lookarounds.

    ✗ Fout 
    Patroon: /<.+>/  →  matcht '<a> en <b>'
    ✓ Correct 
    Patroon: /<[^>]+>/  →  matcht '<a>' en '<b>' afzonderlijk

    Catastrofale backtracking door geneste quantifiers

    `(a+)+b` tegen een lange falende string explodeert exponentieel. De banner Patroon time-out slaat na 250 ms aan; herschrijf om geneste structuur te verwijderen: `a+b` doet hetzelfde werk in lineaire tijd. Atomic-group-simulatie `(?=(a+))\1b` is een andere optie.

    ✗ Fout 
    Patroon: /(a+)+b/  op 'aaaaaaaaaaaaaaaaaaaaac'  →  time-out
    ✓ Correct 
    Patroon: /a+b/  op dezelfde invoer  →  direct 'geen overeenkomst'

    Ankers $ en ^ gedragen zich niet als Python's \A en \Z

    In JavaScript betekenen `^` en `$` regel-start / regel-einde ALLEEN als /m aan is; anders betekenen ze string-start / string-einde. Python's `\A` en `\Z` (die altijd string-grenzen betekenen) bestaan niet in JS. Schakel /m naar behoefte.

    ✗ Fout 
    Patroon: /^Error/  op een multi-line log zonder /m  →  matcht alleen de eerste regel
    ✓ Correct 
    Patroon: /^Error/m  op dezelfde invoer  →  matcht elke regel die met Error begint

    $1 in een string gebruikt maar replace aangeroepen met een functie

    `text.replace(re, '$1')` breidt de terugverwijzing uit. `text.replace(re, () => '$1')` geeft een letterlijke string '$1' terug omdat functies geen sjabloon-tokens zien. Binnen de functie komen vastleggroepen binnen als positionele argumenten.

    ✗ Fout 
    text.replace(/(\w+)/, m => '$1')  →  levert letterlijk '$1' op
    ✓ Correct 
    text.replace(/(\w+)/, (_, g1) => g1.toUpperCase())  →  gebruikt de vastlegging

    Unicode-tekens matchen niet met \w of .

    Default `\w` is `[A-Za-z0-9_]`. Om elke letter in elk schrift te matchen, schakel /u in en schakel over naar `\p{Letter}` (`\p{L}`). De punt stopt ook standaard bij newlines — gebruik /s (dotAll) als je een echte any-character wilt.

    ✗ Fout 
    Patroon: /\w+/  matcht 'hello' maar niet 'héllo' of '你好'
    ✓ Correct 
    Patroon: /\p{Letter}+/u  matcht alle drie

    PCRE-patroon geplakt; SyntaxError gekregen

    JavaScript ondersteunt geen atomic groups `(?>...)`, possessieve quantifiers `a++`, inline modifiers `(?i)`, conditionals `(?(1)yes|no)` of `\A` / `\Z`. De parser-fout benoemt het overtredende construct — herschrijf naar het JS-ondersteunde equivalent (lookaround-simulatie, aparte flag-toggle, alternatie).

    ✗ Fout 
    Patroon: (?i)foo  →  SyntaxError: invalid group
    ✓ Correct 
    Patroon: foo met /i-flag aan  →  hetzelfde effect

    Wie gebruikt deze tool

    Formulierinvoer valideren vóór release
    Bevestig dat je e-mail- / telefoon- / postcode- / gebruikersnaam-regex matcht wat je verwacht — en weigert wat je niet wilt — over randgevallen (Unicode-namen, plus-aliasing, internationale formaten) heen voordat de validatie productie bereikt en echte gebruikers afwijst.
    Data uit logs en configs halen
    Bouw een patroon dat request-ID's, statuscodes, latencies of stack-trace-regels uit een willekeurige log-slice trekt. Benoemde groepen maken de data zelfdocumenterend; het paneel Overeenkomsten toont offsets zodat je dezelfde regex daarna door `rg --replace` of `grep -oE` kunt halen.
    Zoek/vervang over een codebase
    Schets hier een refactor-patroon (bv. `(\w+)\.apply\(null,\s*\[(.*?)\]\)` → `$1($2)`), voorvertoon de substitutie tegen representatieve snippets en plak vervolgens de gevalideerde regex met vertrouwen in de project-brede zoek/vervang van je editor.
    Een online gevonden patroon op consistentie checken
    Een regex van StackOverflow of een blog geplakt? Drop hem in het tabblad Uitleg — elke token krijgt een platte annotatie. Vangt subtiele issues af (`.+?` waar je `.+` wilde, ontbrekende `^`/`$`-ankers, per ongeluk hebzuchtige quantifiers) voordat de regex in je code landt.
    Regex aan een teamgenoot uitleggen
    Open het tabblad Uitleg op een werkend patroon en loop het token voor token door. De kleurcodering (escape / quantifier / character class / groep / anker / alternatie) laat de leerling de structurele vorm van de regex zien, niet alleen de tekens.
    Een patroon tussen talen porten
    Heb je een Python- of PCRE-regex die je in JavaScript moet gebruiken? Plak hem hier. Parset hij, dan toont de uitleg je de JS-equivalente semantiek; doet hij dat niet, dan benoemt de parser-fout het overtredende construct (atomic groups, possessieve quantifiers, inline `(?i)`) zodat je weet wat je moet herschrijven.
    Een trage productie-regex debuggen
    Verdenk je een server-regex van catastrofale backtracking, plak hem dan in deze tester met een sample van de invoer. De wall-clock-bewaking van 250 ms slaat aan op pathologische gevallen en geeft je direct een diagnose voordat je naar profiler-tooling grijpt — en de uitleg wijst naar de geneste-quantifier als grondoorzaak.

    Engine- & algoritme-notities

    ECMA-262 RegExp-engine (native browser)
    Gebruikt `new RegExp(pattern, flags)` en de engine die met V8 / JavaScriptCore / SpiderMonkey wordt geleverd — dezelfde regex-semantiek die je overal in JavaScript krijgt. Patronen die hier valideren draaien ongewijzigd in Node.js, Deno, Bun en elke moderne browser.
    Match-iteratie via String.matchAll
    Globale iteratie gebruikt `text.matchAll(regex)` in plaats van een handmatige lastIndex-loop, zodat elke overeenkomst zijn vastlegroepen, benoemde groepen en (met /d) [start, end]-indices meedraagt. Zero-width overeenkomsten worden afgehandeld met de standaard +1 lastIndex-stap om oneindige loops te voorkomen.
    Wall-clock-time-out voor ReDoS-bescherming
    Een budget van 250 milliseconden wikkelt elke match-, vervang- en split-aanroep. De engine kan intern nog steeds backtracken op één match-poging, maar de buitenste iteratie coöpereert met het budget — pathologische patronen breken af met `timedOut: true` en de UI toont een waarschuwing in plaats van het tabblad te blokkeren.
    Herimplementatie van vervangingssjablonen
    Het tabblad Vervangen parset $1..$N, $&, $`, $', $$ en $ handmatig in plaats van te delegeren aan `String.replace`, zodat de voorvertoning zich identiek gedraagt over engines heen (oudere Safari, oudere Node) waar benoemd-groep-sjablonen randgevallen hebben. De output is precies wat huidige JavaScript-engines produceren.
    Patroon-tokenizer voor de uitleg
    Het tabblad Uitleg draait een handgeschreven tokenizer die elk patroonfragment classificeert (escape / metakarakter / quantifier / character class / groep-open / groep-sluit / anker / alternatie). Onbekende constructen vallen door naar `literal` met een algemene notitie, zodat de uitleg nooit stilzwijgend content laat vallen.
    Permalinks via URL-hash (nooit verzonden)
    De share-state is gecodeerd in het location.hash-fragment (`#p=…&f=…&t=…&tab=…`). Browsers verzenden het fragment nooit in HTTP-requests, dus de servers van go-tools.org ontvangen nul data wanneer een permalink wordt geopend. De hydratie gebeurt volledig op het apparaat van de ontvanger.

    Best practices voor regex

    Veranker patronen wanneer dat je bedoeling is
    `^pattern$` matcht een exacte string; `pattern` matcht overal. De verkeerde keuze is de meest voorkomende bug in formuliervalidatie: een ontbrekende `^` laat een voorafgaande `attacker.com/` door een domeincheck glippen; een ontbrekende `$` laat afsluitende rommel door. Gebruik het tabblad Match tegen opzettelijk kapotte samples om te bevestigen wat wordt afgewezen.
    Geef de voorkeur aan niet-vastleggende groepen voor pure structuur
    `(?:foo|bar)+` en `(foo|bar)+` zijn functioneel identiek, maar de eerste alloceert geen vastleggroep. Grijp naar `(?:…)` wanneer de groep alleen bestaat voor een quantifier of alternatie — dat houdt je genummerde $1..$N stabiel en bespaart een minieme hoeveelheid engine-werk.
    Gebruik de /u-flag voor alles buiten ASCII
    Zonder /u behandelen de punt en `\w` surrogate-pair-tekens (emoji, niet-BMP code points) als twee UTF-16 units. Met /u zijn het er één code point elk — wat je gebruikers zullen waarnemen. /u schakelt ook `\p{Letter}` en andere property escapes in. Default naar /u voor nieuwe patronen, tenzij je een specifieke reden hebt om dat niet te doen.
    Benoem je vastleggroepen
    `(?\d{4})-(?\d{2})` is zelfdocumenterend. Lees je de regex zes maanden later terug, dan is `m.groups.year` duidelijk het jaar — `m[1]` niet. Vervangingssjablonen met $ overleven groep-herordening ook: positionele sjablonen breken op het moment dat iemand een andere groep toevoegt.
    Test faalgevallen, niet alleen succes
    Een regex-tester is voor de fouten. Bevestig wat je patroon matcht en muteer dan opzettelijk de testtekst om te zien wat niet — voorafgaande witruimte, afsluitende witruimte, ontbrekende delen, extra delen, verkeerde case, gemengde schriften. Patronen die geldige invoer doorlaten maar rommel accepteren zijn de bugs die productie als eerste blootlegt.

    Veelgestelde vragen

    Wordt mijn regex of testtekst naar jullie server gestuurd?
    Nee. Elke match-, vervang-, split- en uitleg-operatie draait in JavaScript in je browser met behulp van de native RegExp-engine. Je patroon en tekst worden niet geüpload, niet gelogd, niet op schijf opgeslagen en niet naar een derde partij verzonden. Alleen je UI-voorkeuren (actief tabblad + welke flags je meestal aan hebt) worden in localStorage opgeslagen zodat de pagina ze de volgende keer onthoudt — nooit het patroon of de testtekst. Je kunt het zelf verifiëren door DevTools → Netwerk te openen: typen in een van beide vakken triggert nul verzoeken. Dat maakt de tool veilig voor proprietary patronen, geredigeerde log-samples, interne config en alles wat je niet in regex101 zou plakken.
    Welke regex-flavor gebruikt deze tester — PCRE, Python, Java, JavaScript?
    ECMA-262 (JavaScript), het dialect dat door V8, JavaScriptCore en SpiderMonkey wordt geïmplementeerd — dezelfde engine die je krijgt van `new RegExp(pattern, flags)` in elke browser, Node.js, Deno of Bun. Dat betekent dat de ondersteunde features zijn: vastlegroepen (genummerd + benoemd met `(?...)`), lookaheads `(?=...)` en `(?!...)`, lookbehinds `(?<=...)` en `(?...)`, possessieve quantifiers `a++`, conditionals `(?(1)yes|no)` en inline modifiers `(?i)` gooien een syntax error. Python's `re.VERBOSE` wordt hier niet ondersteund. Voor Python/Java/Go-regex port je het patroon terug naar zijn native engine — de meeste eenvoudige patronen gaan ongewijzigd over, en de uitleg hier is flavor-neutraal.
    Wat doen de flags g, i, m, s, u, y en d elk?
    g (global) — vind elke overeenkomst, niet alleen de eerste; vereist om te itereren met .matchAll en voor globale vervanging. i (case-insensitive) — A en a matchen hetzelfde teken. m (multiline) — ^ en $ verankeren bij elke regelafbreking, niet alleen bij start/einde van de hele invoer. s (dotAll) — . matcht ook newlines; zonder /s stopt een punt bij \n. u (unicode) — schakelt \u{HHHH}-escapes, Unicode property escapes (\p{Letter}) in en behandelt het patroon als een reeks Unicode code points in plaats van UTF-16 code units. y (sticky) — verankert elke overeenkomst op lastIndex, handig voor tokenizers. d (hasIndices, ES2022) — vult `.indices` en `.indices.groups` met [start, end]-paren voor elke groep; deze tester gebruikt /d onder de motorkap om de groepsgrenzen te tekenen. Schakel ze in als chips boven de testtekst; de canonieke /pattern/flags-literal staat in de readout.
    Hoe schrijf ik vastlegroepen en hoe verwijs ik ernaar terug?
    Wikkel een sub-patroon in haakjes: `(\d{4})-(\d{2})-(\d{2})` geeft je drie positionele groepen, toegankelijk als $1, $2, $3 in vervangingen of als m.groups[0..2] in het paneel Overeenkomsten. Gebruik `(?...)` voor benoemde groepen: `(?\d{4})-(?\d{2})` laat je $/$ in het vervangingssjabloon schrijven. Gebruik `(?:...)` voor een niet-vastleggende groep als je alleen groepering nodig hebt voor een quantifier (`(?:foo|bar)+`) — dat maakt geen terugverwijzing aan, waardoor je genummerde $1..$N stabiel blijven. Binnen hetzelfde patroon verwijs je naar een eerdere vastlegging met `\1`, `\2`, enz. — handig om verdubbelde woorden te vinden zoals `\b(\w+)\s+\1\b`.
    Hoe werken lookahead en lookbehind, en waar zijn ze goed voor?
    Lookarounds zijn zero-width assertions — ze checken of iets matcht (of niet) zonder tekens te consumeren. `(?=foo)` (positieve lookahead) slaagt als `foo` volgt op de huidige positie; `(?!foo)` (negatieve lookahead) slaagt als `foo` NIET volgt. `(?<=foo)` en `(?
    Waarom blokkeert mijn regex de browser, en wat is catastrofale backtracking?
    Catastrofale backtracking gebeurt als een patroon geneste quantifiers heeft over overlappende alternatieven — de klassieke vorm is `(a+)+`, `(a|aa)+`, `(\w*)*` of `(?:a|a?)+`. Bij een invoer waarbij de match op het laatste teken kan falen, probeert de engine een exponentieel aantal groepssplitsingen voordat hij opgeeft. Op `aaaaaaaaaaaaaaaaaaaaab` met het patroon `(a+)+b` zijn dat 2^21 ≈ 2 miljoen backtracks vóór het antwoord. Deze tester wikkelt elke match-aanroep in een wall-clock budget van 250 ms — wordt het budget overschreden, dan stopt de iteratie en zie je een waarschuwing Patroon time-out. Oplossingen: veranker het patroon aan zijn grenzen (`^...$`), kies niet-overlappende alternatieven (`(a|b)` in plaats van `(a|aa)`), pak geneste quantifiers uit (`a+` in plaats van `(a+)+`), of herschrijf met possessief-achtige idiomen (`(?=(a+))\1` simuleert `a++` in JS).
    Hoe verschilt deze regex-tester van regex101.com?
    Drie verschillen. (1) Privacy: regex101 stuurt elke toetsaanslag naar zijn servers voor backend-evaluatie en bewaart patronen in gedeelde community-links; deze tool draait volledig in je browser, geen netwerkaanroepen. (2) Snelheid: een server-roundtrip bij elke wijziging voegt 80-300 ms toe; hier updaten matches binnen 10 ms zelfs op lange tekst. (3) Flavor-focus: regex101 ondersteunt PCRE, Python, Java, .NET, JavaScript, Rust en Go met feature-flag UI; deze tool focust op ECMA-262 (JavaScript) — de flavor die elke browser, Node, Deno en Bun shippen — en de uitleg plus permalinks zijn afgestemd op die ene flavor. Heb je PCRE-only features nodig, dan is regex101 nog steeds de juiste tool; voor JavaScript/TypeScript-werk is dit sneller en privater. Permalinks hier zijn URL-hashes (geen upload), dus een gedeelde link reproduceert je patroon lokaal op de machine van de ontvanger.
    Hoe escape ik speciale tekens zoals . | ( ) [ ] { } * + ? ^ $ \?
    Zet er een backslash voor: `\.`, `\|`, `\(`, `\)`, `\[`, `\]`, `\{`, `\}`, `\*`, `\+`, `\?`, `\^`, `\$`, `\\`. Forward slash `/` hoeft niet ge-escaped te worden in een via string doorgegeven patroon (alleen in JS-regex-literals tussen de slashes). Binnen een character class `[...]` verliezen de meeste metakarakters hun speciale betekenis, dus `[.]`, `[*]`, `[+]` matchen allemaal een letterlijk teken — de enige metakarakters die speciaal blijven zijn `]`, `\`, `^` (alleen aan het begin om te negeren) en `-` (range als hij tussen twee tekens staat). Bij twijfel: plak de letterlijke tekst in het patroon en draai de uitleg — elke escape-sequentie krijgt een eenregelige beschrijving in het uitlegpaneel.
    Kan ik een regex met een collega delen via een link?
    Ja — en de link bevat geen server-roundtrip. Klik op Link kopiëren in de actiebalk: de tester codeert je patroon, flags, testtekst en actief tabblad in de URL-hash (`#p=...&f=gim&t=...&tab=match`). Iedereen die de link opent hydratiseert de pagina met dezelfde state — lokaal op zijn machine. Omdat de data in het hash-fragment leeft, wordt het nooit naar de go-tools.org-server gestuurd (browsers verzenden fragmenten niet in requests) en het wordt niet in onze access-logs gelogd. De linklengte groeit met de tekstomvang, dus voor samples >2 KB kopieer je de regex via Kopieer /pattern/flags en plak je de tekst apart. Voor collaboratieve regex-review zonder de feitelijke tekst te delen: deel alleen het patroon en de flags — de ontvanger plakt zijn eigen corpus en krijgt dezelfde overeenkomsten.
    Ondersteunt de tester Unicode, emoji en niet-Latijnse schriften?
    Ja. Schakel de /u-flag in voor volledige Unicode-verwerking: \w matcht Latijnse woord-tekens (de default-semantiek), maar met /u kun je bredere categorieën matchen via Unicode property escapes — `\p{Letter}` matcht elke letter in elk schrift, `\p{Script=Han}` matcht Chinese ideogrammen, `\p{Emoji}` matcht emoji, `\p{Number}` matcht elk cijfer/numerieken. Zonder /u worden surrogate-pair-emoji zoals 👨‍💻 als twee UTF-16 code units gezien en zullen patronen als `^.$` ze niet matchen; met /u behandelt de punt elk grapheme code point als één teken. Voor RTL-schriften (Arabisch, Hebreeuws) werken patronen zonder speciale behandeling — richting is een render-time-aangelegenheid, geen regex-engine-aangelegenheid. CJK-content matcht op dezelfde manier als Latijns.
    Wat is het verschil tussen .match, .matchAll, .replace en .split met een regex?
    String.prototype.match geeft de eerste overeenkomst terug (of een array van alle overeenkomsten als /g aanstaat) maar verliest vastlegroepen als /g aan is. String.prototype.matchAll vereist /g en geeft een iterator van match-arrays MET vastlegroepen en indices — wat deze tester intern gebruikt. String.prototype.replace accepteert een string-sjabloon ($1, $&, enz.) of een callback die per overeenkomst wordt aangeroepen met (match, ...groups, offset, string, namedGroups). String.prototype.split splitst op elke overeenkomst — handig met /g, maar de global-flag wordt voor split-semantiek genegeerd. Deze tool toont match via het tabblad Match, replace via Vervangen en split via Splitsen, dus je kunt elke variant voorvertonen zonder de pagina te verlaten; de literal /pattern/flags ligt één klik weg als je klaar bent om in code te plakken.
    Waarom werkt mijn Python- of Java-regex hier niet?
    Omdat deze tester ECMA-262 (JavaScript) draait — de meeste patronen porten netjes, een handvol niet. Veelvoorkomende port-valkuilen: (1) Python's inline flags `(?i)` en `(?x)` zijn niet geldig in JS — gebruik in plaats daarvan de flag-chips erboven. (2) Python's `\A` en `\Z` zijn `^` en `$` in JS (met /m voor regelankers). (3) Java/Python-conditionals `(?(name)yes|no)` worden niet ondersteund in JS — herschrijf met een alternatie. (4) Possessieve quantifiers `a++` en atomic groups `(?>...)` zijn niet beschikbaar in JS — simuleer met `(?=(a+))\1`. (5) Python `(?P...)` is `(?...)` in JS. (6) `\h` voor horizontale witruimte en `\v` voor verticale zitten niet in JS — gebruik `[ \t]` en `[\n\r]`. Voor een draagbare port breekt de uitleg af wat elke token doet, zodat je niet-ondersteunde syntax kunt vervangen door een equivalent.
    Is er een maximum tekstgrootte of aantal overeenkomsten?
    Praktische limiet: ongeveer 200.000 tekens testtekst en 500 gehighlighte overeenkomsten tegelijk getoond. Boven de 500 overeenkomsten toont het paneel Overeenkomsten een banner Toon eerste 500; de count-badge rapporteert nog steeds het echte totaal. Het wall-clock-budget van 250 ms begrenst op hol geslagen patronen ongeacht de grootte. Voor logbestanden van meerdere megabytes draai je de regex met command-line `grep -oE` of `rg` (ripgrep) — die streamen en raken geen UI-render-cap. Voor een eenmalige scan van enorme tekst plak je een representatieve slice in deze tester om het patroon te valideren, en draai je het gevalideerde patroon vervolgens tegen het volledige bestand in je shell.

    Gerelateerde tools

    Alle tools bekijken →

    Tekst vergelijken & Diff

    Tekstverwerking

    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.

    Gratis woordenteller & tekentelling

    Tekstverwerking

    Tel direct woorden, tekens, zinnen, alinea's en leestijd. Live woordenteller met limietcontroles voor Twitter, meta description en Instagram. Gratis, privé, geen account nodig.

    Talstelsel omrekenen — online converter

    Omrekentools

    Reken je getal direct om tussen binair, hex, decimaal, octaal en elk talstelsel (2-36). Gratis en privé — alles draait in je browser.

    Base64 decoderen en encoderen online

    Encodering en formattering

    Base64 decoderen en encoderen direct in je browser. Realtime conversie met volledige UTF-8- en emoji-ondersteuning. 100% privé — geen account nodig.

    Crontab generator & cron-uitdrukking bouwen

    Datum en tijd

    Bouw, valideer en ontleed cron-uitdrukkingen in je browser. Live preview van de volgende run in lokale tijd of UTC. POSIX 5-veld syntaxis, presets, uitleg in begrijpelijk Nederlands. Gratis, privé, geen account nodig.

    CSV naar JSON omzetter

    Encodering en formattering

    Zet CSV om naar JSON in uw browser. RFC 4180, type-afleiding, headerregel, big-int veilig. 100% privé, geen upload.