JPKCom DB

Regex Debugger — Beispiele

Durchläufe mit dem Regex Debugger: E-Mails matchen, Gruppen lesen, Flags und Lookaround testen, ersetzen, splitten und Code für PHP/Python erzeugen.

Zurück zur Übersicht: Regex Debugger · Tool live öffnen: www.jpkc.com/tools/regex/

Das Manual beschreibt jedes Feld und jeden Flag. Diese Seite ergänzt das um konkrete Durchläufe: echte, in der JavaScript-Engine lauffähige Muster, jeweils mit dem passenden Test-Text und der Erklärung, was du in der Treffer-Anzeige siehst. Alle Beispiele kannst du direkt eintippen — Muster ins Pattern-Feld, Text ins Test String-Feld, Flags wie angegeben setzen, Ersetzungen ins Feld Replacement im Tab Replace.

Beispiel 1: E-Mail-Adressen matchen

Der Klassiker — alle E-Mail-Adressen in einem Text finden. Fang mit einem naheliegenden Muster an:

  • Pattern: [\w.+-]+@[\w-]+\.[\w.-]+
  • Flags: g
  • Test String:
Schreib an info@example.com oder an support@mail.example.org.
Spam an: nope@.com (ungültig).

Matches listet zwei Treffer, jeweils mit pos X–Y, und markiert sie farbig im Text. nope@.com wird nicht getroffen, weil direkt hinter dem @ mindestens ein Wortzeichen stehen muss. Schau dir aber den zweiten Treffer genau an: support@mail.example.org. — der Satzpunkt am Ende gehört mit dazu, weil [\w.-]+ auch Punkte frisst. Genau dafür ist der Debugger da: Du siehst sofort, wo dein Muster zu großzügig ist.

Die Lösung steckt in der Library unter „E-mail address (pragmatic)": [\w.+-]+@[\w-]+(?:\.[\w-]+)+. Hier muss jeder Punkt der Domain von mindestens einem Wortzeichen gefolgt sein — der Satzpunkt fällt heraus, der zweite Treffer lautet sauber support@mail.example.org. Schalte g testweise aus und beobachte, wie die Liste auf nur den ersten Treffer zusammenschrumpft.

Beispiel 2: Capture-Gruppen lesen — ein Datum zerlegen

Capture-Gruppen fangen Teile eines Treffers separat ein. Hier zerlegst du ein Datum in Tag, Monat und Jahr.

  • Pattern: (\d{2})\.(\d{2})\.(\d{4})
  • Flags: g
  • Test String:
Termin am 19.06.2026, Deadline 30.06.2026.

Jeder Treffer zeigt unter dem Match-Wert die nummerierten Gruppen: Gruppe 1 den Tag, Gruppe 2 den Monat, Gruppe 3 das Jahr — jede Nummer in der Farbe, mit der die Gruppe im Test-String unterstrichen ist. So prüfst du, ob deine Klammern die richtigen Stücke fassen, bevor du sie im Code über match[1], match[2] … weiterverarbeitest. Beachte: Die Punkte im Muster sind als \. escaped — ein nackter . würde jedes Zeichen treffen.

Beispiel 3: Benannte Capture-Gruppen

Statt dir Gruppe 1/2/3 zu merken, gibst du den Gruppen Namen.

  • Pattern: (?<day>\d{2})\.(?<month>\d{2})\.(?<year>\d{4})
  • Flags: g
  • Test String:
Termin am 19.06.2026.

In Matches steht jetzt hinter jeder Gruppennummer zusätzlich ihr Name — <day>, <month> und <year> — und dann der Wert. Im Code liest du sie später über match.groups.day aus — lesbarer und robuster, als sich auf Klammer-Reihenfolgen zu verlassen. Das Start-Beispiel des Tools, (?<word>\w+), zeigt dasselbe Prinzip an einzelnen Wörtern.

Beispiel 4: Flags ausprobieren — i, m und s

Dieselbe Eingabe, drei Flags, drei Ergebnisse. Nimm diesen mehrzeiligen Text:

Fehler: Datei nicht gefunden
fehler: Zugriff verweigert
OK: alles gut
  1. i (case insensitive). Pattern fehler, nur g: trifft nur die kleingeschriebene Zeile. Schalte i dazu — jetzt matchen beide „Fehler"-Zeilen, egal ob groß oder klein.
  2. m (multiline). Pattern ^fehler, Flags g und i. Ohne m matcht der Anker ^ nur ganz am Stringanfang — du bekommst nur das „Fehler" der ersten Zeile, die zweite wird nicht erfasst. Mit m passt ^ auf jeden Zeilenanfang, und die „fehler"-Zeile mitten im Text wird ebenfalls getroffen.
  3. s (dotall). Pattern gefunden.*Zugriff, nur g. Ohne s matcht . keinen Zeilenumbruch, der Treffer kommt nicht zustande. Mit s darf . auch Newlines überspringen — der Ausdruck spannt jetzt über die Zeilengrenze hinweg. Im Tab Explain siehst du den Unterschied auch in Worten: Ohne s steht beim Punkt „any character except line breaks", mit s „any character, including newlines".

So bekommst du ein Gefühl dafür, dass die Flags keine Kosmetik sind, sondern die Semantik des Musters verändern.

Beispiel 5: Lookaround — Kontext prüfen, ohne ihn zu fangen

Lookahead und Lookbehind prüfen die Umgebung eines Treffers, ohne sie selbst Teil des Matches zu machen. JavaScript beherrscht beide Richtungen.

  • Pattern (Lookbehind): (?<=€\s?)\d+(?:,\d{2})?
  • Flags: g
  • Test String:
Preis: € 19,99 — reduziert von € 29,99. Artikelnummer 12345.

Der positive Lookbehind (?<=€\s?) verlangt, dass vor der Zahl ein Euro-Zeichen (optional mit Leerzeichen) steht — gematcht wird aber nur die Zahl. So findest du Beträge, ohne die 12345 ohne Euro-Präfix einzusammeln. In der Trefferliste siehst du jeweils nur 19,99 und 29,99, nicht das €.

Beispiel 6: Ungültiges Muster und Nulllängen-Treffer

Zwei lehrreiche Randfälle.

  • Ungültiges Muster: Tippe (unbalanciert ins Pattern-Feld. Es lässt sich kein RegExp bauen — die Trefferliste bleibt leer, unter den Flags erscheint die Original-Fehlermeldung der Engine, und der Zähler steht auf „Error". Schließt du die Klammer ((unbalanciert)), verschwindet der Fehler sofort.
  • Nulllängen-Treffer: Pattern \b, Flags g, beliebiger Text. Eine Wortgrenze hat keine Breite — sie matcht „zwischen" Zeichen. Das Tool zählt diese Treffer korrekt durch (jeder als „(empty)" mit pos X–X, Start gleich Ende), ohne sich in der Endlosschleife zu verfangen, die ein globaler Nulllängen-Match sonst auslösen würde.

Beispiel 7: Katastrophales Backtracking — der Timeout

Was passiert, wenn ein Muster exponentiell viele Wege ausprobiert, zeigt dieses Experiment gefahrlos:

  • Pattern: (a+)+$
  • Flags: g
  • Test String: dreißig a, gefolgt von einem Ausrufezeichen:
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!

Weil am Ende das ! steht, kann $ nie passen — die Engine probiert deshalb jede Aufteilung der a-Kette auf die innere und die äußere Wiederholung durch. Nach 1,5 Sekunden bricht das Tool ab: Der Zähler zeigt „Timeout", die Statuszeile nennt verschachtelte Quantoren als wahrscheinliche Ursache. Die Seite bleibt dabei bedienbar. Ersetze das Muster durch a+$, und das Ergebnis — kein Treffer — steht sofort da. Wie du solche Muster entschärfst, steht in den Tipps.

Beispiel 8: Suchen und Ersetzen — Datumsformat umstellen

Der Tab Replace zeigt dir das Ergebnis von String.replace(), bevor du es in deinen Code überträgst. Am schnellsten geht es über die Library: Wähle „ISO date (named groups)". Das Tool setzt:

  • Pattern: (?<year>\d{4})-(?<month>0[1-9]|1[0-2])-(?<day>0[1-9]|[12]\d|3[01])
  • Flags: g
  • Test String:
Released 2026-10-15, updated 2026-12-31. Invalid: 2026-13-01
  • Replacement: $<day>.$<month>.$<year>

Wechsle in den Tab Replace. Das Ergebnis lautet:

Released 15.10.2026, updated 31.12.2026. Invalid: 2026-13-01

Die beiden gültigen Daten sind ins deutsche Format umgestellt, 2026-13-01 bleibt stehen, weil der Monat 13 nicht zur Gruppe month passt. Über dem Ergebnis steht „All matches replaced.". Schalte g aus — jetzt heißt es „Without flag g only the first match is replaced.", und nur das erste Datum ändert sich. Mit Copy result übernimmst du den umgebauten Text. Die Ersetzungsbausteine $1, $<name>, $& und Co. fügst du per Klick aus dem Cheat-Sheet-Abschnitt Replacement ein.

Beispiel 9: Text zerlegen mit Split

Der Tab Split zeigt, was text.split(regex) liefert — inklusive der Eigenheit, dass Capture-Gruppen mit im Ergebnis landen.

  • Pattern: \s*[,;]\s*
  • Flags: g
  • Test String:
Apfel, Birne;Kirsche ,Pflaume

Die Liste zeigt vier Einträge, nummeriert ab 0: Apfel, Birne, Kirsche, Pflaume — die Leerzeichen um die Trennzeichen sind verschwunden, weil das Muster sie mitfrisst. Setze nun eine Gruppe um die Trennzeichen: \s*([,;])\s*. Jetzt enthält die Liste sieben Einträge, weil jedes gefangene Trennzeichen zwischen den Teilen auftaucht: Apfel, ,, Birne, ;, Kirsche, ,, Pflaume. Willst du gruppieren, ohne dass die Gruppe im Split auftaucht, nimm eine nicht-fangende Gruppe (?:…).

Beispiel 10: Muster erklären lassen und nach PHP oder Python exportieren

Nimm das Datumsmuster aus Beispiel 3 und gib im Tab Replace eine Ersetzung an, die das Datum ins ISO-Format dreht:

  • Pattern: (?<day>\d{2})\.(?<month>\d{2})\.(?<year>\d{4})
  • Flags: g
  • Replacement: $<year>-$<month>-$<day>

Im Tab Explain liest du das Muster Baustein für Baustein: „Start of capturing group 1 "day"", darunter eingerückt \d als „a digit (0–9)" und {2} als „… repeated exactly 2 times — as many as possible (greedy)", dann „End of group 1 "day"" und so weiter.

Im Tab Code wählst du unter Language die Zielsprache. Für PHP (PCRE) erzeugt das Tool unter anderem:

$pattern = '/(?<day>\\d{2})\\.(?<month>\\d{2})\\.(?<year>\\d{4})/';
// …
$result = preg_replace($pattern, '${3}-${2}-${1}', $text);

Weil preg_replace() keine benannten Referenzen kennt, hat das Tool $<year> & Co. in Gruppennummern übersetzt — ein gelber Hinweis über dem Code sagt dir das. Für Python (re) wird daraus:

pattern = re.compile(r'(?P<day>\d{2})\.(?P<month>\d{2})\.(?P<year>\d{4})')
# …
result = pattern.sub(r'\g<year>-\g<month>-\g<day>', text)

Hier weisen die Hinweise darauf hin, dass die benannten Gruppen in die Python-Syntax (?P<name>…) umgeschrieben wurden und dass \d in Python 3 auch Nicht-ASCII-Ziffern trifft (Abhilfe: re.ASCII). Mit Copy code übernimmst du das Ergebnis.

Noch tiefer: die Übersicht zum großen Bild, das Manual für jede Funktion im Detail und die Tipps & Tricks für Stolperfallen und Engine-Eigenheiten. Ausprobieren kannst du alles direkt im Tool.