Regex-Tester & Debugger

Testen und debuggen Sie reguläre Ausdrücke für JavaScript lokal im Browser.

Kein Upload nötigOhne RegistrierungSofortige Ergebnisse
Flags g · i · m · s · u · v · yErfassungs- & benannte Gruppen + Ersetzen100% Lokal • Keine Uploads
Regulären Ausdruck testen
Offline-Engine bereit100 % privater Browser-Arbeitsbereich • Keine Cloud-Uploads
100% Privat • Keine Server-Datei-Uploads

Warum das kostenlose Regex-Tester & Debugger von Utiliome nutzen?

Entwickelt für höchsten Datenschutz, sofortige Ausführung und einfache Nutzung. Keine Abos oder Registrierungen erforderlich.

Native ECMA-262 RegExp-Parität

Wird direkt in der ECMAScript-RegExp-Engine Ihres Browsers ausgeführt – mit sofortigem Umschalten der Flags für global (g), case-insensitive (i), multiline (m), dotAll (s), Unicode (u) und sticky (y).

Inspektor für indizierte & benannte Capture Groups

Extrahiert nullbasierte [start, end)-UTF-16-Code-Unit-Bereiche, nummerierte Submatches ($1 bis $99) sowie Dictionaries benannter Capture Groups ((?<name>...)) für jeden Treffer in mehrzeiligen Payloads.

Live-Vorschau für Ersetzungen & Backreferences

Wertet Vorlagen für String.prototype.replace und replaceAll in Echtzeit mit $1, $<name>, $& (gesamter Treffer), $' (Suffix nach dem Treffer) sowie $$ für literale Dollarzeichen aus.

ReDoS-Erkennung & Datenschutz ohne Upload

Markiert verschachtelte Quantifizierer, die anfällig für Catastrophic Backtracking sind, während sensible Produktions-Logs, Bearer-Tokens und personenbezogene Daten (PII) strikt im lokalen Browserspeicher verbleiben.

Utiliome vs. traditionelle Cloud-Tools

Vergleichen Sie unsere lokale WebAssembly-Engine mit alten Cloud-Tools.

Funktion Utiliome (Lokaler Browser) Klassische Cloud-Konverter
Native ECMA-262 RegExp-Parität Wird direkt in der ECMAScript-RegExp-Engine Ihres Browsers ausgeführt – mit sofortigem Umschalten der Flags für global (g), case-insensitive (i), multiline (m), dotAll (s), Unicode (u) und sticky (y). Eingeschränkte Optionen ohne erweiterte Anpassung
Inspektor für indizierte & benannte Capture Groups Extrahiert nullbasierte [start, end)-UTF-16-Code-Unit-Bereiche, nummerierte Submatches ($1 bis $99) sowie Dictionaries benannter Capture Groups ((?<name>...)) für jeden Treffer in mehrzeiligen Payloads. Erfordert externe Tools oder manuelle Nachbearbeitung
Datenschutz & Verarbeitung 100 % lokale Browser-Verarbeitung (null Server-Uploads) Lädt Daten auf externe Cloud-Server hoch
Preismodell & Konto-Pflicht Dauerhaft 100 % kostenlos ohne Registrierung Erfordert Registrierung oder kostenpflichtiges Abo
So funktioniert's

Regex-Tester & Debugger in 3 einfachen Schritten nutzen

Keine Softwareinstallation erforderlich. Alles läuft direkt in Ihrem Webbrowser.

1

Pattern eingeben und Engine-Flags aktivieren

Geben Sie den regulären Ausdruck ohne umschließende Schrägstriche ein und aktivieren Sie genau die ECMAScript-Flags (g, i, m, s, u, y), die Ihre JavaScript- oder TypeScript-Laufzeitumgebung verwendet.

2

Testdaten einfügen und Capture Groups prüfen

Fügen Sie Test-Strings ein oder laden Sie eine lokale Logdatei, um hervorgehobene Match-Grenzen, Zeichenindex-Bereiche, nummerierte Capture-Slots und (?<name>...)-Gruppenzuordnungen zu untersuchen.

3

Ersetzungen testen und Ausdruck kopieren

Geben Sie optional einen Ersetzungs-String mit $1, $<name> oder $&-Referenzen ein, um den transformierten Text live zu prüfen, und kopieren Sie anschließend Ihr validiertes Regex-Literal.

Strukturierte Logs mit Named Capture Groups und Live-Ersetzungen debuggen

Schnelle Antwort: Kombinieren Sie benannte Capture Groups ((?<name>...)) mit den Flags für global (g) und multiline (m), um strukturierte Logzeilen in Key-Value-Dictionaries zu parsen, exakte UTF-16-Match-Offsets zu verifizieren und $<name>-String-Transformationen vor dem Deployment zu testen.

Beim Debuggen regulärer Ausdrücke gegen mehrzeilige Telemetrie- oder Access-Logs führen subtile Fehler bei Ankern oder Quantifizierern oft zu stillschweigenden Fehlversuchen oder verschobenen nummerierten Gruppen. Betrachten wir zwei strukturierte Anwendungs-Logzeilen mit ISO-8601-Zeitstempeln, Severity-Tags, Service-IDs, 16-stelligen Hex-Trace-IDs, HTTP-Statuscodes und Gleitkomma-Latenzen:

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

Um jede Zeile deterministisch und ohne fehleranfällige Positionsindizes zu parsen, binden Sie jedes Feld an eine benannte ECMAScript-Capture-Group ((?<name>...)), umschließen die optionalen Nachkommastellen der Millisekunden mit einer nicht-erfassenden Gruppe ((?:...)) und aktivieren sowohl g (globale Iteration) als auch m (zeilenweise Anker ^ und $):

^(?<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+)?)$

Ohne das m-Flag verankern ^ und $ ausschließlich an Index 0 und am Ende des gesamten Puffers, wodurch der Ausdruck fehlschlägt, sobald ein Zeilenumbruch (\n) Datensätze trennt. Mit aktivem gm löst der Capture-Group-Debugger jede Match-Iteration sowohl in 1-basierte positionale Submatches als auch in ein strukturiertes groups-Objekt auf:

{
  "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"
  }
}

Sobald die Capture-Grenzen verifiziert sind, können Sie die Formatierung für String.prototype.replaceAll direkt im Ersetzungsbereich testen. Die Vorlage [$<level>] $<service>: HTTP $<status> ($<ms>ms, trace=$<trace>) erzeugt sofort eine normalisierte Ausgabe:

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

Semantik der ECMA-262 RegExp-Engine, Flag-Mechanik und Catastrophic Backtracking

Schnelle Antwort: Reguläre Ausdrücke in JavaScript laufen auf einem Backtracking-NFA gemäß ECMA-262 Abschnitt 22.2 und arbeiten auf 16-Bit-UTF-16-Code-Units, sofern das u-Flag nicht volles Unicode-Skalar-Matching aktiviert. Das Vermeiden mehrdeutiger verschachtelter Quantifizierer verhindert exponentielle O(2^n)-ReDoS-Blockaden.

Ausführung des Backtracking-NFA und zustandsbehaftetes `lastIndex`

Im Gegensatz zu reinen DFA-Engines (Deterministic Finite Automata) implementieren ECMAScript-Engines (V8 Irregexp, JavaScriptCore Yarr, SpiderMonkey) einen Backtracking-NFA (Nondeterministic Finite Automaton), um Rückreferenzen (\1, \k<name>) und beliebige Lookaround-Assertions ((?=...), (?!...), (?<=...), (?<!...)) zu unterstützen. Durch | getrennte Alternativen werden von links nach rechts ausgewertet; gierige (greedy) Quantifizierer (*, +, ?, {m,n}) konsumieren so viele Zeichen wie möglich, bevor sie schrittweise zurücksetzen (Backtracking), um nachfolgende Tokens zu erfüllen, während genügsame (reluctant) Quantifizierer (*?, +?, ??, {m,n}?) zuerst die kürzeste Expansion prüfen.

Wenn g (global) oder y (sticky) gesetzt ist, liest und modifiziert RegExp.prototype.exec() die lastIndex-Eigenschaft der Instanz:

  • Global (g): Sucht ab lastIndex, setzt lastIndex nach jedem Treffer auf dessen End-Offset (oder erhöht bei Treffern der Länge null um einen Unicode-Codepoint) und setzt den Wert bei einem Fehlschlag auf 0 zurück.
  • Sticky (y): Verankert den Abgleich strikt an lastIndex, ohne vorausschauend zu suchen. Beginnt an lastIndex kein Treffer, schlägt der Abgleich sofort fehl und setzt lastIndex auf 0 zurück, was y ideal für den Bau von Zero-Copy-Lexern macht.

Zeilenumbrüche, UTF-16-Surrogate und das `u`-Flag

ECMA-262 erkennt exakt vier Codepoints als Zeilenumbruch an: \n (U+000A), \r (U+000D), Line Separator (U+2028) und Paragraph Separator (U+2029). Das Aktivieren von m lässt ^ und $ an den Grenzen zu diesen vier Codepoints matchen; das Aktivieren von s (dotAll) erlaubt es ., diese ebenfalls zu erfassen.

Standardmäßig werden JavaScript-Strings als Sequenzen von 16-Bit-UTF-16-Code-Units indiziert. Ergänzende Unicode-Zeichen oberhalb von U+FFFF (wie Emojis oder mathematische Symbole) belegen ein Surrogatpaar aus zwei Einheiten (0xD800–0xDBFF High-Surrogat gefolgt von 0xDC00–0xDFFF Low-Surrogat). Ohne u ergibt /^.$/.test("🚀") den Wert false, da "🚀".length gleich 2 ist. Das Aktivieren von u stellt den Abgleich auf 21-Bit-Unicode-Skalarwerte um, schaltet Unicode-Property-Escapes (\p{Letter}, \p{Script=Latin}, \P{Control}) frei und deaktiviert fehlertolerante Legacy-Identitäts-Escapes aus Annex B, sodass ungültige Escapes sofort beim Kompilieren fehlschlagen.

ECMA-262 `GetSubstitution`-Ersetzungsgrammatik

Die Live-Ersetzung folgt der standardisierten GetSubstitution-Tabelle:

  • $$: Fügt ein einzelnes literales $-Zeichen ein.
  • $&: Fügt den gesamten gefundenen Teilstring ein (match[0]).
  • $': Fügt den Teilstring ein, der auf den Trefferbereich folgt.
  • $n / $nn: Fügt die 1-indizierte nummerierte Capture Group n (1 bis 99) ein.
  • $<name>: Fügt den erfassten String für (?<name>...) ein, oder einen leeren String "", falls die benannte Gruppe im aktuellen Match-Zweig nicht beteiligt war.

Prävention von Catastrophic Backtracking (ReDoS)

Regular Expression Denial of Service (ReDoS) entsteht, wenn verschachtelte oder überlappende Quantifizierer – wie (a+)+$, ([a-zA-Z0-9]+\s?)*$ oder (.*a){12} – identische Teilstrings über exponentiell viele Partitionen (O(2^n) Schritte) matchen, bevor sie an einem abschließenden Zeichen scheitern. Da ECMA-262 weder possessive Quantifizierer (++) noch atomare Gruppen ((?>...)) bietet, sollten Sie Patterns wie folgt absichern:

  1. Disjunkte Zeichenklassen: Ersetzen Sie gieriges .* zwischen Trennzeichen durch negierte Klassen wie [^,\r\n]*, damit die Engine keine Trennzeichengrenzen überschreiten kann.
  2. Delimiter Unrolling: Schreiben Sie ^(\w+-?)+$ (mehrdeutig, wenn - fehlt) als ^\w+(?:-\w+)*$ um, was die Worst-Case-Komplexität auf strikt lineares O(n) reduziert.
  3. Atomare Emulation per Lookahead: Wo Backtracking in einen Teilausdruck unterbunden werden muss, erfassen Sie diesen innerhalb eines positiven Lookaheads und konsumieren ihn sofort über eine Rückreferenz: (?=(\w+))\1.

Regex Tester vs. Regex-Generator: Welches Tool benötigen Sie?

Schnelle Antwort: Nutzen Sie den Regex Tester & Debugger, wenn Sie bereits ein Pattern haben und Match-Offsets prüfen, benannte Capture Groups debuggen, ECMAScript-Flags umschalten oder $<name>-Ersetzungen gegen echte Payloads testen möchten. Nutzen Sie den Regex-Generator, wenn Sie einen neuen Ausdruck visuell zusammenstellen oder Regex-Code für mehrere Sprachen exportieren möchten.

Obwohl das Testen und Erstellen zum selben Workflow für reguläre Ausdrücke gehören, lösen sie unterschiedliche Entwicklungsaufgaben. Der Regex Tester & Debugger ist eine interaktive Diagnose-Workbench, mit der Sie untersuchen, wie sich ein bestehendes ECMAScript-Pattern gegenüber komplexen realen Eingaben verhält. Wenn Sie stattdessen einen neuen Ausdruck aus visuellen Bausteinen zusammensetzen, mit einer RFC-konformen Vorlage starten oder sauber maskierten Code für Python, Go oder Rust exportieren möchten, wechseln Sie zum Regex-Generator.

Funktion Regex Tester & Debugger Regex-Generator
Primäre Entwicklungsaufgabe Treffer, Capture-Bereiche, Flags und Ersetzungen bestehender Patterns debuggen Neue Patterns visuell aus Bausteinen oder geprüften RFC-Presets konstruieren
Ausgangseingabe Roher Regex-Ausdruck, ECMAScript-Flags sowie mehrzeiliger Testtext oder Logs Kombinierbare Token-Blöcke oder Entwickler-Rezepte (UUID, SemVer, IPv4, ISO-8601)
Capture-Group-Debugging Vollständige [start, end)-Offsets, $1–$99-Array-Slots und (?<name>...)-Dictionary Pass/Fail-Validierung anhand positiver und negativer Test-Fixtures
Live-String-Ersetzung Echtzeit-Vorschau für replace / replaceAll mit $1, $<name>, $& und $$ Nicht auf Texttransformations-Templates ausgerichtet
Multi-Language-Code-Export Ausgabe als ECMAScript- / JavaScript-Regex-Literal und Pattern Idiomatische Snippets für JavaScript, Python (re), Go (regexp) und Rust (regex)
Fokus der Engine-Architektur Native ECMA-262-Backtracking-NFA-Semantik und ReDoS-Erkennung Engine-übergreifende Portabilität zwischen ECMA-262, Python re und linearer RE2

Empfohlener Workflow

Starten Sie im Regex-Generator, wenn Sie Validierungsregeln für strukturierte Bezeichner wie Semantic Versioning, RFC-9562-UUIDs oder URL-Slugs über mehrsprachige Services hinweg entwerfen. Sobald ein Pattern in einer Frontend- oder Node.js-Pipeline im Einsatz ist – oder wenn ein Ausdruck in Produktions-Logs unerwartet einen Edge Case verfehlt –, fügen Sie den Ausdruck und den Log-Auszug hier im Regex Tester & Debugger ein, um Zeichenbereiche pro Treffer, lastIndex-Wechselwirkungen der Flags und Ersetzungsvorlagen im Detail zu prüfen.

FAQ

Regex-Tester & Debugger FAQ und technische Anleitung

Alles, was Sie über die Nutzung des kostenlosen Online-regex tester online von Utiliome wissen müssen.

Warum liefert ein globaler Regex mit RegExp.prototype.test() in JavaScript abwechselnd true und false zurück?

Wenn das globale (g) oder Sticky-Flag (y) auf einem JavaScript-RegExp-Objekt gesetzt ist, verändert jeder Aufruf von .test() oder .exec() die lastIndex-Eigenschaft der Instanz so, dass sie unmittelbar hinter den gefundenen Teilstring zeigt. Der nächste .test()-Aufruf setzt die Suche ab lastIndex statt ab Index 0 fort; erreicht er das Ende des Strings ohne weiteren Treffer, gibt er false zurück und setzt lastIndex wieder auf 0. Für eine zustandslose boolesche Validierung sollten Sie das g-Flag weglassen oder regex.lastIndex = 0 explizit zurücksetzen.

Was ist der Unterschied zwischen indizierten Capture Groups, Non-Capturing Groups und Named Capture Groups?

Standardklammern (...) speichern gefundene Teilstrings in fortlaufenden, 1-basierten Capture-Slots ($1, $2) sowie im von exec() zurückgegebenen Array. Nicht-erfassende Gruppen (?:...) gruppieren Tokens für Quantifizierer oder Alternationen, ohne ein Submatch aufzuzeichnen oder nachfolgende $n-Indizes zu verschieben. Benannte Capture Groups (?<name>...) befüllen sowohl ihren fortlaufenden nummerierten Slot als auch match.groups.name (in Ersetzungs-Strings als $<name> nutzbar), was Index-Fehler bei späteren Änderungen am Pattern verhindert.

Wann sollte ich das Unicode-Flag (u) in regulären ECMAScript-Ausdrücken aktivieren?

Aktivieren Sie u immer dann, wenn Sie Nicht-ASCII-Benutzertexte, Emojis, ergänzende CJK-Ideogramme oder Unicode-Zeichenkategorien abgleichen. Ohne u wertet JavaScript Strings als 16-Bit-UTF-16-Code-Units aus, wodurch . oder negierte Klassen wie [^x] 4-Byte-Surrogatpaare oberhalb von U+FFFF in fehlerhafte Halbsurrogate aufspalten. Das Einschalten von u stellt das Matching auf vollständige 21-Bit-Unicode-Codepoints um, aktiviert \p{...}-Property-Escapes wie \p{Letter} und \p{Number} und erzwingt eine strikte Syntaxvalidierung bei unbekannten Escape-Sequenzen.

Wie funktionieren Ersetzungs-Tokens wie $&, $1 und $<name> in der Live-Ersetzungsvorschau?

Die Ersetzungsvorschau implementiert den GetSubstitution-Algorithmus gemäß ECMA-262, der von String.prototype.replace() und replaceAll() verwendet wird. $& fügt den gesamten gefundenen Teilstring ein, $1 bis $99 fügen die entsprechende nummerierte Capture Group ein, $<name> setzt den von (?<name>...) erfassten Text ein, $' fügt alles nach dem Treffer ein, Dollar-Backtick fügt alles vor dem Treffer ein und $$ gibt ein literales $-Zeichen aus.

Was verursacht Catastrophic Backtracking (ReDoS) und wie schreibe ich anfällige Patterns um?

Catastrophic Backtracking tritt in Backtracking-NFA-Engines auf, wenn verschachtelte oder überlappende Quantifizierer – wie (a+)+b oder ^([a-zA-Z0-9]+\s?)*$ – dieselbe Eingabesequenz auf O(2^n) Arten partitionieren können, bevor sie an einem unerwarteten abschließenden Zeichen scheitern. Beseitigen Sie Mehrdeutigkeiten, indem Sie gierige .*-Bereiche durch negierte Zeichenklassen ([^,\r\n]*) ersetzen, optionale Trennzeichen in ^[a-zA-Z0-9]+(?:\s[a-zA-Z0-9]+)*$ entrollen und offene Quantifizierer mit expliziten Obergrenzen ({1,64}) versehen. Um von Grund auf RE2-kompatible Patterns mit linearer Laufzeit zu erstellen, nutzen Sie den Regex-Generator.