Regex-tester & Debugger

Test en debug reguliere expressies voor JavaScript lokaal in je browser.

Geen uploadsGeen registratieDirect resultaat
Vlaggen g · i · m · s · u · v · yvanggroepen & benoemde groepen + vervangen100% Lokaal • Geen Uploads
Reguliere expressie testen
Offline engine gereed100% privé in-browser werkomgeving • Nul cloud-uploads
100% Privé • Geen Server Uploads

Waarom Utiliome's gratis Regex-tester & Debugger gebruiken?

Van de grond af opgebouwd voor strikte privacy, directe uitvoering en nul wrijving. Geen registratie nodig.

Native ECMA-262 RegExp-pariteit

Wordt rechtstreeks uitgevoerd op de ECMAScript regular expression-engine van je browser, met direct schakelen tussen flags voor global (g), case-insensitive (i), multiline (m), dotAll (s), Unicode (u) en sticky (y).

Inspector voor geïndexeerde & benoemde Capture Groups

Extraheert zero-based [start, end) UTF-16 code-unit bereiken, genummerde submatches ($1 t/m $99) en dictionaries met named capture groups ((?<name>...)) voor elke match in multiline payloads.

Live preview van substituties & backreferences

Evalueert String.prototype.replace- en replaceAll-templates in realtime met behulp van $1, $<name>, $& (volledige match), $' (suffix na match) en $$ voor letterlijke dollartekens.

ReDoS-detectie & privacy zonder uploads

Markeert geneste quantifiers die gevoelig zijn voor catastrophic backtracking, terwijl gevoelige productielogs, bearer-tokens en klantgegevens (PII) strikt in het lokale browsergeheugen blijven.

Utiliome vs. traditionele cloudtools

Vergelijk onze lokale WebAssembly-engine met verouderde cloudtools.

Functie Utiliome (Lokale Browser) Verouderde Cloud Converters
Native ECMA-262 RegExp-pariteit Wordt rechtstreeks uitgevoerd op de ECMAScript regular expression-engine van je browser, met direct schakelen tussen flags voor global (g), case-insensitive (i), multiline (m), dotAll (s), Unicode (u) en sticky (y). Beperkte opties zonder geavanceerde aanpassing
Inspector voor geïndexeerde & benoemde Capture Groups Extraheert zero-based [start, end) UTF-16 code-unit bereiken, genummerde submatches ($1 t/m $99) en dictionaries met named capture groups ((?<name>...)) voor elke match in multiline payloads. Vereist externe tools of handmatige bewerking
Privacy & Gegevensverwerking 100% lokale verwerking in je browser (geen uploads) Uploadt gegevens naar externe cloudservers
Prijsmodel & Accountvereisten 100% gratis voor altijd zonder registratie Vereist accountregistratie of betaald abonnement
Hoe het werkt

Hoe Regex-tester & Debugger te gebruiken in 3 eenvoudige stappen

Geen software-installatie vereist. Alles draait direct in je webbrowser.

1

Voer patroon in en schakel engine-flags in

Typ je reguliere expressie zonder omsluitende slashes en activeer exact de ECMAScript-flags (g, i, m, s, u, y) die door je JavaScript- of TypeScript-runtime worden gebruikt.

2

Plak testdata en inspecteer captures

Plak teststrings of laad een lokaal logbestand om gemarkeerde matchgrenzen, karakterindex-bereiken, genummerde capture-slots en (?<name>...)-groepskoppelingen te inspecteren.

3

Bekijk vervangingen en kopieer expressie

Voer een optionele vervangingsstring in met $1, $<name> of $&-referenties om de getransformeerde tekst live te controleren, en kopieer vervolgens je gevalideerde regex-literal.

Gestructureerde logs debuggen met Named Capture Groups en live vervangingen

Kort antwoord: Combineer named capture groups ((?<name>...)) met de global (g) en multiline (m) flags om gestructureerde logregels te parsen naar key-value dictionaries, exacte UTF-16 match-offsets te verifiëren en $<name>-stringtransformaties te testen voordat je code naar productie brengt.

Bij het troubleshooten van reguliere expressies op multiline telemetrie- of access-logs zorgen subtiele fouten in anchors of quantifiers vaak voor stille non-matches of verschoven genummerde groepen. Bekijk deze twee gestructureerde applicatielogregels met ISO-8601-tijdstempels, severity-tags, service-identifiers, 16-karakter hexadecimale trace-ID's, HTTP-statuscodes en floating-point latencies:

2026-11-01T14:22:08.419Z [ERROR] svc=checkout trace_id=4bf92f3577b34da6 status=502 latency_ms=184.7
2026-11-01T14:22:09.004Z [INFO] svc=inventory trace_id=00f067aa0ba902b7 status=200 latency_ms=12.3

Om elke regel deterministisch te parsen zonder kwetsbare positionele array-indexering, koppel je elk veld aan een ECMAScript named capture group ((?<name>...)), plaats je de optionele fractionele milliseconden in een non-capturing group ((?:...)), en schakel je zowel g (globale iteratie) als m (^ en $ anchors per regel) in:

^(?<ts>\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z)\s+\[(?<level>ERROR|WARN|INFO)\]\s+svc=(?<service>[a-z0-9_-]+)\s+trace_id=(?<trace>[0-9a-f]{16})\s+status=(?<status>\d{3})\s+latency_ms=(?<ms>\d+(?:\.\d+)?)$

Zonder de m-flag verankeren ^ en $ uitsluitend op index 0 en het einde van de volledige buffer, waardoor de expressie faalt zodra een newline (\n) records van elkaar scheidt. Met gm actief zet de capture group debugger elke match-iteratie om in zowel 1-based positionele submatches als een gestructureerd groups-object:

{
  "matchIndex": 0,
  "span": [0, 99],
  "fullMatch": "2026-11-01T14:22:08.419Z [ERROR] svc=checkout trace_id=4bf92f3577b34da6 status=502 latency_ms=184.7",
  "captures": [
    "2026-11-01T14:22:08.419Z",
    "ERROR",
    "checkout",
    "4bf92f3577b34da6",
    "502",
    "184.7"
  ],
  "groups": {
    "ts": "2026-11-01T14:22:08.419Z",
    "level": "ERROR",
    "service": "checkout",
    "trace": "4bf92f3577b34da6",
    "status": "502",
    "ms": "184.7"
  }
}

Zodra de capture-grenzen zijn geverifieerd, kun je de String.prototype.replaceAll-opmaak rechtstreeks in het substitutiepaneel testen. Het invoeren van de template [$<level>] $<service>: HTTP $<status> ($<ms>ms, trace=$<trace>) levert direct genormaliseerde output op:

[ERROR] checkout: HTTP 502 (184.7ms, trace=4bf92f3577b34da6)
[INFO] inventory: HTTP 200 (12.3ms, trace=00f067aa0ba902b7)

ECMA-262 RegExp-enginesemantiek, flag-mechanica en Catastrophic Backtracking

Kort antwoord: Reguliere expressies in JavaScript draaien op een backtracking-NFA zoals gedefinieerd in ECMA-262 sectie 22.2 en werken op 16-bits UTF-16 code-units, tenzij de u-flag volledige Unicode-scalarmatching inschakelt. Het vermijden van ambigue geneste quantifiers voorkomt exponentiële O(2^n) ReDoS-vertragingen.

Uitvoering van de Backtracking-NFA en stateful `lastIndex`

In tegenstelling tot pure Deterministic Finite Automata (DFA)-engines implementeren ECMAScript-engines (V8 Irregexp, JavaScriptCore Yarr, SpiderMonkey) een backtracking Nondeterministic Finite Automaton (NFA) ter ondersteuning van backreferences (\1, \k<name>) en willekeurige lookaround-assertions ((?=...), (?!...), (?<=...), (?<!...)). Alternatieven gescheiden door | worden van links naar rechts geëvalueerd; greedy quantifiers (*, +, ?, {m,n}) consumeren zoveel mogelijk tekens voordat ze stap voor stap backtracken om aan volgende tokens te voldoen, terwijl reluctant (lazy) quantifiers (*?, +?, ??, {m,n}?) eerst de kortste expansie proberen.

Wanneer g (global) of y (sticky) is ingesteld, leest en muteert RegExp.prototype.exec() de lastIndex-property van de instantie:

  • Global (g): Zoekt op of na lastIndex, verplaatst lastIndex naar de eind-offset van elke match (of verhoogt met één Unicode-codepoint bij matches met lengte nul) en reset naar 0 wanneer er geen match meer wordt gevonden.
  • Sticky (y): Verankert het matchen strikt op lastIndex zonder vooruit te scannen. Als er geen match begint op lastIndex, faalt de poging onmiddellijk en wordt lastIndex teruggezet naar 0, wat y ideaal maakt voor het bouwen van zero-copy lexicale scanners.

Regelscheidingstekens, UTF-16-surrogaten en de `u`-flag

ECMA-262 herkent exact vier codepoints als regelscheidingsteken (line terminator): \n (U+000A), \r (U+000D), Line Separator (U+2028) en Paragraph Separator (U+2029). Het inschakelen van m zorgt ervoor dat ^ en $ matchen op de grenzen naast deze vier codepoints; het inschakelen van s (dotAll) staat toe dat . deze tekens ook matcht.

Standaard worden JavaScript-strings geïndexeerd als reeksen van 16-bits UTF-16 code-units. Aanvullende Unicode-tekens boven U+FFFF (zoals emoji's of wiskundige symbolen) nemen een surrogaatpaar van twee eenheden in beslag (0xD800–0xDBFF high surrogate gevolgd door 0xDC00–0xDFFF low surrogate). Zonder u evalueert /^.$/.test("🚀") naar false, omdat "🚀".length gelijk is aan 2. Het inschakelen van u schakelt over op 21-bits Unicode-scalarwaarden, ontgrendelt Unicode property escapes (\p{Letter}, \p{Script=Latin}, \P{Control}) en schakelt tolerante legacy identity escapes uit Annex B uit, zodat ongeldige escapes direct tijdens het compileren falen.

ECMA-262 `GetSubstitution`-vervangingsgrammatica

Live tekstvervanging volgt de standaard GetSubstitution-tabel:

  • $$: Voegt één letterlijk $-teken in.
  • $&: Voegt de volledige gematchte substring in (match[0]).
  • $': Voegt de substring in die volgt op het gematchte bereik.
  • $n / $nn: Voegt de 1-indexed genummerde capture n (1 t/m 99) in.
  • $<name>: Voegt de afgevangen string voor (?<name>...) in, of een lege string "" wanneer de benoemde groep niet deelnam aan de huidige match-branch.

Preventie van Catastrophic Backtracking (ReDoS)

Regular Expression Denial of Service (ReDoS) ontstaat wanneer geneste of overlappende quantifiers—zoals (a+)+$, ([a-zA-Z0-9]+\s?)*$ of (.*a){12}—identieke substrings matchen via een exponentieel aantal partities (O(2^n) stappen) voordat ze falen op een afsluitend teken. Omdat ECMA-262 geen possessive quantifiers (++) en atomic groups ((?>...)) ondersteunt, maak je patronen weerbaar door:

  1. Wederzijds uitsluitende karaktersets: Vervang greedy .* tussen scheidingstekens door ontkende karakterklassen zoals [^,\r\n]*, zodat de engine nooit over scheidingstekens heen kan lezen.
  2. Delimiter Unrolling: Herschrijf ^(\w+-?)+$ (ambigu wanneer - ontbreekt) als ^\w+(?:-\w+)*$, waardoor de worst-case complexiteit terugvalt naar strikt lineair O(n).
  3. Lookahead Atomic Emulatie: Waar backtracking in een subexpressie verboden moet worden, vang je deze af binnen een positieve lookahead en consumeer je het resultaat direct via een backreference: (?=(\w+))\1.

Regex Tester vs. Regex Generator: Welke tool heb je nodig?

Kort antwoord: Gebruik de Regex Tester & Debugger wanneer je al een patroon hebt en match-offsets wilt inspecteren, named capture groups wilt debuggen, ECMAScript-flags wilt testen of $<name>-tekstvervangingen wilt uitvoeren op echte payloads. Gebruik de Regex Generator wanneer je visueel een nieuwe expressie wilt opbouwen of regex-code voor meerdere programmeertalen wilt exporteren.

Hoewel testen en genereren deel uitmaken van dezelfde workflow voor reguliere expressies, lossen ze verschillende engineeringproblemen op. Regex Tester & Debugger is een interactieve diagnostische werkbank om te inspecteren hoe een bestaand ECMAScript-patroon zich gedraagt op complexe praktijkdata. Als je in plaats daarvan een nieuwe expressie wilt samenstellen uit visuele bouwstenen, wilt beginnen vanaf een RFC-preset, of geëscapete boilerplate wilt exporteren voor Python, Go of Rust, schakel dan over naar de Regex Generator.

Functionaliteit Regex Tester & Debugger Regex Generator
Primaire engineeringtaak Matches, capture-bereiken, flags en vervangingen debuggen op bestaande patronen Visueel nieuwe patronen opbouwen uit blokken of geverifieerde RFC-presets
Startinvoer Ruwe regex-expressie, ECMAScript-flags en multiline testtekst of logs Combineerbare token-blokken of developer-recepten (UUID, SemVer, IPv4, ISO-8601)
Capture Group Debugging Volledige [start, end) offset-bereiken, $1–$99 array-slots en (?<name>...) dictionary Pass/fail-validatie met positieve en negatieve test-fixtures
Live tekstsubstitutie Realtime replace / replaceAll preview met $1, $<name>, $& en $$ Niet gericht op teksttransformatie-templates
Multi-language code-export ECMAScript / JavaScript regex-literal en patroonuitvoer Idiomatische snippets voor JavaScript, Python (re), Go (regexp) en Rust (regex)
Focus op engine-architectuur Native ECMA-262 backtracking-NFA-semantiek en ReDoS-detectie Cross-engine portabiliteit tussen ECMA-262, Python re en lineaire RE2

Aanbevolen workflow

Begin in de Regex Generator bij het opzetten van validatieregels voor gestructureerde identifiers zoals semantic versions, RFC 9562 UUID's of URL-slugs over meertalige services heen. Zodra een patroon draait in een frontend- of Node.js-pipeline—of wanneer een expressie onverwacht een edge-case mist in productielogs—plak je de expressie en het ruwe logfragment hier in Regex Tester & Debugger om karakterbereiken per match, lastIndex-flag-interacties en substitutie-templates te analyseren.

Veelgestelde vragen

Regex-tester & Debugger FAQ en Technische Gids

Alles wat je moet weten over het gebruik van Utiliome's gratis online regex tester online.

Waarom geeft een globale regex afwisselend true en false terug met RegExp.prototype.test() in JavaScript?

Wanneer de global (g) of sticky (y) flag is ingesteld op een JavaScript RegExp-object, muteert het aanroepen van .test() of .exec() de lastIndex-property van de instantie zodat deze direct na de gematchte substring wijst. De volgende .test()-aanroep hervat het scannen vanaf lastIndex in plaats van index 0; zodra het einde van de string wordt bereikt zonder een nieuwe match, retourneert de methode false en wordt lastIndex teruggezet naar 0. Laat voor stateless booleaanse validatie de g-flag weg of zet regex.lastIndex = 0 expliciet terug.

Wat is het verschil tussen geïndexeerde capture groups, non-capturing groups en named capture groups?

Standaard haakjes (...) slaan gematchte substrings op in opeenvolgende 1-based capture-slots ($1, $2) en in de array die door exec() wordt geretourneerd. Non-capturing groups (?:...) groeperen tokens voor quantifiers of alternatie zonder een submatch vast te leggen of volgende $n-indices te verschuiven. Named capture groups (?<name>...) vullen zowel hun opeenvolgende genummerde slot als match.groups.name (toegankelijk als $<name> in vervangingsstrings), wat voorkomt dat indexen breken wanneer patronen later worden aangepast.

Wanneer moet ik de Unicode (u) flag inschakelen bij ECMAScript reguliere expressies?

Schakel u in zodra je niet-ASCII gebruikerstekst, emoji's, aanvullende CJK-ideogrammen of Unicode-karaktercategorieën matcht. Zonder u evalueert JavaScript strings als 16-bits UTF-16 code-units, waardoor . of ontkende klassen zoals [^x] 4-byte surrogaatparen boven U+FFFF opsplitsen in corrupte halve surrogaten. Het activeren van u schakelt matching over op volledige 21-bits Unicode-codepoints, ontgrendelt \p{...} property escapes zoals \p{Letter} en \p{Number}, en dwingt strikte syntaxvalidatie af bij onbekende escapes.

Hoe werken vervangingstokens zoals $&, $1 en $<name> in de live substitutie-preview?

Substitutie-previews implementeren het ECMA-262 GetSubstitution-algoritme dat wordt gebruikt door String.prototype.replace() en replaceAll(). $& voegt de volledige gematchte substring in, $1 t/m $99 voegen de bijbehorende genummerde capture group in, $<name> voegt de tekst in die is afgevangen door (?<name>...), $' voegt alles na de match in, dollar-backtick voegt alles vóór de match in en $$ geeft een letterlijk $-teken terug.

Wat veroorzaakt catastrophic backtracking (ReDoS) en hoe kan ik kwetsbare patronen herschrijven?

Catastrophic backtracking treedt op in backtracking-NFA-engines wanneer geneste of overlappende quantifiers—zoals (a+)+b of ^([a-zA-Z0-9]+\s?)*$—dezelfde invoerreeks op O(2^n) manieren kunnen opdelen voordat ze falen op een onverwacht afsluitend teken. Elimineer ambiguïteit door greedy .*-bereiken te vervangen door ontkende karakterklassen ([^,\r\n]*), optionele scheidingstekens uit te rollen naar ^[a-zA-Z0-9]+(?:\s[a-zA-Z0-9]+)*$, en open quantifiers te begrenzen met expliciete limieten ({1,64}). Gebruik de Regex Generator om vanaf nul RE2-compatibele patronen met lineaire uitvoeringstijd op te bouwen.