# Regex Debugger — Manual

> Vollständige Funktionsbeschreibung des Regex Debuggers: Editoren, alle sechs Flags, Treffer- und Gruppen-Anzeige, Highlighting und die JS-Engine-Grenzen.

Source: https://www.jpkc.com/db/tools/regex/manual/

Zurück zur Übersicht: [Regex Debugger](https://www.jpkc.com/db/tools/regex/) · Tool live öffnen: [www.jpkc.com/tools/regex/](https://www.jpkc.com/tools/regex/)

Dieses Manual beschreibt den **Regex Debugger** vollständig: jedes Eingabefeld, jeden Flag, wie Treffer und Capture-Gruppen dargestellt werden, was das Highlighting tut und welche Grenzen die zugrunde liegende JavaScript-Engine setzt. Die Oberfläche des Tools ist auf Englisch — die Feld- und Button-Bezeichnungen werden hier deshalb in ihrer englischen Original-Schreibweise genannt (mit deutscher Erläuterung), damit du dich im echten Interface zurechtfindest.

## Aufbau und Ablauf

Die Oberfläche ist zweispaltig. Links liegen drei Karten untereinander — **Pattern**, **Test String** und **Matches** —, rechts das eingebaute **Cheat Sheet**. Es gibt **keinen Ausführen-Knopf**: Die Auswertung läuft automatisch, sobald du am Muster, am Text oder an den Flags etwas änderst. Eingaben in den beiden Editoren sind dabei leicht **entkoppelt (ca. 200 ms Debounce)**, damit nicht bei jedem Tastendruck neu gerechnet wird; ein Flag-Klick wirkt sofort.

Der Ablauf intern: Aus Muster und gewählten Flags wird ein `RegExp`-Objekt gebaut, dieses gegen den Test-String ausgeführt, und das Ergebnis erscheint dreifach — als Zähler, als Trefferliste und als farbige Markierung im Text.

## Pattern

Der obere Editor nimmt dein **Regex-Muster** auf — den reinen Ausdruck, **ohne** die umschließenden Schrägstriche und ohne angehängte Flags. Schreibst du im Code `/\d+/g`, gehört hier nur `\d+` hinein; das `g` setzt du über die Flag-Umschalter.

Backslash-Sequenzen schreibst du wie in einem echten regulären Ausdruck, also `\d`, `\w`, `\b` und so weiter — **nicht** doppelt escaped wie in einem JavaScript-String-Literal. Du tippst das Muster so, wie es zwischen den Schrägstrichen stünde.

### Copy pattern

Der Kopier-Button (Symbol) in der Pattern-Toolbar legt dein Muster **im Literal-Format** in die Zwischenablage: `/muster/flags`. Die aktuell gesetzten Flags werden mit übernommen. Ist das Muster leer, kommt ein Hinweis „Nothing to copy" statt einer Kopie. Das Format ist direkt in JavaScript-Code einsetzbar.

### Clear all

Der Lösch-Button (Papierkorb) leert **beide** Editoren — Muster und Test-String — und setzt die Flags auf den Standard zurück: `g` aktiv, alle anderen aus. Danach steht der Cursor wieder im Pattern-Editor.

## Test String

Der mittlere Editor enthält den Text, gegen den dein Muster läuft. Er ist **mehrzeilig** und zeigt **Zeilennummern**, was beim Arbeiten mit den zeilenbezogenen Flags (`m`) und mit längeren Eingaben hilft. Jede Änderung am Text löst (nach kurzer Verzögerung) eine neue Auswertung aus.

## Flags

Unter dem Pattern-Editor liegen sechs Umschalter, die zusammen die Flag-Zeichenkette für das `RegExp`-Objekt bilden. Standardmäßig ist nur **`g`** aktiv. Jeder Flag entspricht exakt dem gleichnamigen JavaScript-Regex-Flag:

### g — global

Sucht **alle** Treffer statt nur des ersten. Das ist im Tool von Haus aus an. Praktisch wichtig: Ist `g` **aus**, zeigt die Trefferliste **nur den ersten Treffer** — das ist kein Fehler, sondern das normale Verhalten der Engine. Für die meisten Debugging-Aufgaben willst du `g` aktiv lassen.

### i — case insensitive

Ignoriert Groß-/Kleinschreibung. `Hallo` trifft dann auch `hallo` und `HALLO`.

### m — multiline

Ändert die Bedeutung der Anker `^` und `$`: Sie passen dann auf **Zeilenanfang und Zeilenende** statt nur auf Anfang und Ende des gesamten Strings. Ohne `m` matcht `^` nur ganz vorne. Mit mehrzeiligem Test-String und Zeilennummern siehst du den Effekt sofort.

### s — dotall

Lässt den Punkt `.` auch **Zeilenumbrüche** treffen. Ohne `s` matcht `.` jedes Zeichen außer dem Newline; mit `s` auch diesen.

### u — unicode

Schaltet die volle Unicode-Verarbeitung ein. Nötig, sobald du mit Unicode-Escapes wie `\u{1F600}` oder Unicode-Property-Escapes wie `\p{L}` arbeitest. Ohne `u` werden manche Sequenzen anders interpretiert.

### y — sticky

Erzwingt einen Treffer **exakt an der aktuellen Position** (`lastIndex`), nicht irgendwo später im String. Spezialfall für Tokenizer-artige Aufgaben; im interaktiven Test selten gebraucht, aber vorhanden.

## Matches

Die untere linke Karte zeigt das Ergebnis. Oben rechts ein Zähler-Badge: **„0 matches"**, **„1 match"** oder **„N matches"**. Solange das Muster leer ist, steht dort „0 matches" und die Liste bleibt leer („Enter a pattern to see matches"). Findet ein gültiges Muster nichts, erscheint „No matches found".

Pro Treffer rendert die Liste einen Eintrag mit:

- **Nummer** — ein laufendes Badge (1, 2, 3 …) in derselben Farbe wie die Markierung im Text.
- **Match value** — der tatsächlich getroffene Text (`match[0]`), farbig hervorgehoben.
- **Position** — die Angabe `pos X-Y`: Start-Index und End-Index des Treffers im String (nullbasiert).

### Capture-Gruppen (nummeriert)

Enthält dein Muster runde Klammern `(…)`, listet der Treffer-Eintrag jede **nummerierte Capture-Gruppe** als `Group 1:`, `Group 2:` und so weiter, jeweils mit ihrem eingefangenen Teilstring. Gruppen, die in diesem Treffer nichts gefangen haben (`undefined`), werden ausgelassen. Die Nummerierung folgt der Reihenfolge der öffnenden Klammern — wie in JavaScript.

### Benannte Capture-Gruppen

Benannte Gruppen `(?<name>…)` erscheinen zusätzlich als eigener Block, dargestellt als `<name>:` mit dem gefangenen Wert. Das Start-Beispiel des Tools (`(?<word>\w+)`) zeigt das direkt. Benannte und nummerierte Darstellung schließen sich nicht aus — eine benannte Gruppe taucht in beiden Listen auf.

### Highlighting im Test-String

Parallel zur Liste markiert das Tool jeden Treffer **direkt im Test-String** farbig. Es rotieren **vier Farben**: Treffer 1, 2, 3, 4 bekommen unterschiedliche Töne, Treffer 5 wieder die erste Farbe und so weiter. So lässt sich auch bei dicht beieinanderliegenden Treffern erkennen, wo einer aufhört und der nächste beginnt. Bei jeder Neuauswertung werden die alten Markierungen entfernt und neu gesetzt.

## Fehleranzeige

Ist dein Muster syntaktisch ungültig (z. B. eine unbalancierte Klammer oder ein ungültiger Quantor), kann die Engine kein `RegExp` bauen. Dann erscheint statt der Trefferliste die **Original-Fehlermeldung** der JavaScript-Engine im Fehlerfeld unter dem Muster, und der Zähler wechselt auf **„Error"**. Die Meldung ist die unveränderte Browser-Meldung (z. B. „Invalid regular expression: …") — sie nennt dir oft direkt die problematische Stelle.

## Cheat Sheet

Rechts liegt ein aufklappbares Nachschlagewerk (Akkordeon), das die wichtigsten Regex-Bausteine als Kurztabellen bereithält — ohne dass du die Seite verlassen musst. Die Abschnitte:

- **Characters** — `.`, `\d`, `\D`, `\w`, `\W`, `\s`, `\S`, `\n`, `\t`.
- **Quantifiers** — `*`, `+`, `?`, `{n}`, `{n,}`, `{n,m}` sowie die Lazy-Varianten `*?` und `+?`.
- **Groups** — `(…)`, `(?:…)`, `(?<name>…)`, Rückverweise `\1` und `\k<name>`, Alternation `(…|…)`.
- **Anchors** — `^`, `$`, `\b`, `\B`.
- **Lookaround** — `(?=…)`, `(?!…)`, `(?<=…)`, `(?<!…)`.
- **Character Classes** — `[abc]`, `[^abc]`, `[a-z]`, `[A-Za-z]`, `[0-9]`.
- **Flags** — die sechs Flags `g/i/m/s/u/y` mit Kurzerklärung.

## Engine und Grenzen

Der Debugger ist **rein clientseitig** und nutzt die native **JavaScript-`RegExp`-API** des Browsers. Es gibt keinen Server-Aufruf, keine Datenübertragung; Muster und Text bleiben auf deinem Gerät. Daraus folgen die wichtigsten Fakten und Grenzen:

- **Du testest die JS-Engine.** Ergebnisse gelten 1:1 für JavaScript/Node.js/TypeScript — aber nicht zwingend für PCRE (PHP), Python `re`, Go oder `.NET`. Unterschiede stehen in den [Tipps](https://www.jpkc.com/db/tools/regex/tips/#javascript-regexp-ist-nicht-pcre).
- **Nur diese sechs Flags.** `g/i/m/s/u/y`. Das `d`-Flag (Match-Indizes) und das `v`-Flag (erweiterte Klassen) sind nicht als Umschalter vorhanden.
- **Kein Replace.** Das Tool ist ein reiner **Matcher/Debugger**. Es zeigt Treffer und Gruppen, bietet aber **keine Suchen-und-Ersetzen-Funktion** und keine `String.replace`-Vorschau. Wenn du ersetzt, baust du das Muster hier, testest es und überträgst es in deinen Code.
- **JavaScript-Featureset.** Verfügbar sind benannte Gruppen, Lookahead und Lookbehind, Rückverweise und (mit `u`) Unicode-Property-Escapes. **Nicht** verfügbar sind PCRE-Eigenheiten wie atomare Gruppen, possessive Quantoren, Rekursion, `\A`/`\Z`/`\z` oder POSIX-Klassen `[[:alpha:]]`.
- **Nulllängen-Treffer** (z. B. `\b` oder `a*` an leeren Stellen) werden korrekt behandelt: Das Tool verhindert die Endlosschleife, die ein globaler Match auf solchen Mustern sonst auslösen würde.
- **Catastrophic Backtracking ist möglich.** Da alles im Browser-Thread läuft, kann ein pathologisches Muster (verschachtelte Quantoren wie `(a+)+$`) auf bestimmten Eingaben den Tab kurzzeitig einfrieren. Das ist kein Tool-Fehler, sondern eine Eigenschaft von Backtracking-Engines — Details und Gegenmittel in den [Tipps](https://www.jpkc.com/db/tools/regex/tips/#catastrophic-backtracking-vermeiden).

Für den Einstieg, die Zielgruppen und das große Bild siehe die [Übersichtsseite](https://www.jpkc.com/db/tools/regex/). Konkrete Durchläufe zeigen die [Beispiele](https://www.jpkc.com/db/tools/regex/examples/). Ausprobieren kannst du alles direkt im [Tool](https://www.jpkc.com/tools/regex/).

