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.
Ons team valideert regex-uitvoer tegen de ECMA-262-specificatie, het RegExp-gedrag van Node.js en cross-engine-pariteitstests in V8 / JavaScriptCore / SpiderMonkey. Het ReDoS-budget is gekalibreerd tegen de gedocumenteerde worst-case-patronen uit de regex-DoS-corpora van Snort en OWASP.
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. (?<year>\d{4})-(?<month>\d{2})-(?<day>\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 (?<name>...)), lookahead- en lookbehind-assertions ((?=...), (?!...), (?<=...), (?<!...)), de zeven canonieke flags (g, i, m, s, u, y, d), Unicode property escapes (\p{Letter}, \p{Script=Han}) onder /u, en \d-stijl character escapes. Patronen die je hier valideert plak je direct in je codebase en werken ongewijzigd. Port je vanuit PCRE, Python of Java, dan ontleedt de uitleg elke token zodat je syntax kunt spotten die niet vertaalt (atomic groups, possessieve quantifiers, inline modifiers).
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- / $&- / $`- / $'- / $$- / $<name>-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 $<name> zodat je de data op dezelfde manier leest als je ze in code consumeert.
Live vervangingsvoorvertoning met $1 / $& / $<name>
Schakel over naar het tabblad Vervangen om je substitutie in realtime toegepast te zien. Het volledige ECMAScript-vervangingsalfabet werkt: $1..$N voor positioneel, $<name> 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 $<year>, $<month>, $<day>. Schakel over naar het tabblad Vervangen en probeer $<day>/$<month>/$<year> 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 $<name> 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
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
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
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 $<name>).
- 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
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.
Patroon: /\d+/ → '1 22 333' levert alleen ['1']
Patroon: /\d+/g → '1 22 333' levert ['1', '22', '333']
Hebzuchtige quantifier consumeerde te veel
.+ consumeert zoveel mogelijk, dus <.+> tegen <a> en <b> legt <a> en <b> vast, niet <a>. Gebruik luie quantifiers (.+?), beperktere character classes ([^>]+), of veranker met lookarounds.
Patroon: /<.+>/ → matcht '<a> en <b>'
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.
Patroon: /(a+)+b/ op 'aaaaaaaaaaaaaaaaaaaaac' → time-out
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.
Patroon: /^Error/ op een multi-line log zonder /m → matcht alleen de eerste regel
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.
text.replace(/(\w+)/, m => '$1') → levert letterlijk '$1' op
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.
Patroon: /\w+/ matcht 'hello' maar niet 'héllo' of '你好'
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).
Patroon: (?i)foo → SyntaxError: invalid group
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 --replaceofgrep -oEkunt 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: trueen de UI toont een waarschuwing in plaats van het tabblad te blokkeren. - Herimplementatie van vervangingssjablonen
- Het tabblad Vervangen parset $1..$N, $&, $
, $', $$ en $<name> handmatig in plaats van te delegeren aanString.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
literalmet 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;patternmatcht overal. De verkeerde keuze is de meest voorkomende bug in formuliervalidatie: een ontbrekende^laat een voorafgaandeattacker.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
\wsurrogate-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
(?<year>\d{4})-(?<month>\d{2})is zelfdocumenterend. Lees je de regex zes maanden later terug, dan ism.groups.yearduidelijk het jaar —m[1]niet. Vervangingssjablonen met $<name> 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?
Welke regex-flavor gebruikt deze tester — PCRE, Python, Java, JavaScript?
new RegExp(pattern, flags) in elke browser, Node.js, Deno of Bun. Dat betekent dat de ondersteunde features zijn: vastlegroepen (genummerd + benoemd met (?<name>...)), lookaheads (?=...) en (?!...), lookbehinds (?<=...) en (?<!...), de zeven flags g/i/m/s/u/y/d, Unicode property escapes (\p{Letter}) onder /u, en terugverwijzingen \1..\9. PCRE-only features zoals atomic groups (?>...), 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?
.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?
(\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 (?<name>...) voor benoemde groepen: (?<year>\d{4})-(?<month>\d{2}) laat je $<year>/$<month> 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?
(?=foo) (positieve lookahead) slaagt als foo volgt op de huidige positie; (?!foo) (negatieve lookahead) slaagt als foo NIET volgt. (?<=foo) en (?<!foo) zijn de lookbehind-tegenhangers. Praktische toepassingen: een substring extraheren zonder de omgeving mee te nemen ((?<=\$)\d+ matcht de cijfers na een dollarteken, maar $ is geen deel van de overeenkomst), valideren met meerdere constraints in één patroon ((?=.*[A-Z])(?=.*\d).{8,} vereist minstens één hoofdletter, één cijfer en 8 tekens), en voorkomen van voorkomens (^(?!.*\bpassword\b) wijst elke regel met het woord password af). Modern ECMA-262 ondersteunt lookbehind van variabele lengte, dus (?<=^prefix-?) werkt. Waarom blokkeert mijn regex de browser, en wat is catastrofale backtracking?
(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?
Hoe escape ik speciale tekens zoals . | ( ) [ ] { } * + ? ^ $ \?
\., \|, \(, \), \[, \], \{, \}, \*, \+, \?, \^, \$, \\. 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?
#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?
\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?
Waarom werkt mijn Python- of Java-regex hier niet?
(?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<name>...) is (?<name>...) 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?
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 →Case converter — UPPERCASE, lowercase, camelCase & meer
Tekstverwerking
Zet tekst direct om tussen UPPERCASE, lowercase, Title Case, Sentence case, camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE en 6 andere formaten. Gratis, alleen in de browser, geen account nodig.
Lorem Ipsum-generator — gratis opvultekst
Tekstverwerking
Genereer direct Lorem Ipsum-opvultekst — per alinea, zin, woord, byte of lijst. Kopieer of download als platte tekst, HTML, Markdown of JSON. 100% gratis, privé, in de browser. Geen registratie.
Dubbele regels uit tekst verwijderen
Tekstverwerking
Verwijder dubbele regels uit tekst online — gratis, direct, 100% in je browser. Negeer hoofdletters of witruimte, houd het eerste of laatste voorkomen, en zie hoeveel duplicaten er zijn verwijderd. Ook sorteren. Geen account.
URL-slug-generator — slugify elke tekst
Tekstverwerking
Slugify elke titel direct tot een schone, SEO-vriendelijke URL-slug. Translitereer accenten en Cyrillisch, of behoud Unicode-letters. 100% privé, in je browser.
Tekstregels alfabetisch & natuurlijk sorteren
Tekstverwerking
Sorteer tekstregels alfabetisch, numeriek (natuurlijke volgorde) of op lengte — oplopend of aflopend. Gratis online regelsorteerder, 100% in je browser. Ook dedupliceren, omkeren en lijsten opschonen. Geen account.
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.