# Regex Debugger — Beispiele

> Lauffähige Durchläufe mit dem Regex Debugger: E-Mails matchen, Capture-Gruppen lesen, benannte Gruppen, Flags ausprobieren und Lookaround testen.

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

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/)

Das [Manual](https://www.jpkc.com/db/tools/regex/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.

## Beispiel 1: E-Mail-Adressen matchen

Der Klassiker — alle E-Mail-Adressen in einem Text finden.

- **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).
```

Mit aktivem `g` listet **Matches** beide gültigen Adressen als Treffer 1 und 2, jeweils mit `pos X-Y`, und markiert sie farbig im Text. Die ungültige Variante `nope@.com` wird (je nach Muster) gar nicht oder nur teilweise getroffen — genau dafür ist der Debugger da: Du siehst sofort, wo dein Muster zu großzügig oder zu streng ist. 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: `Group 1:` den Tag, `Group 2:` den Monat, `Group 3:` das Jahr. 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 `Group 1/2/3` zu merken, gibst du den Gruppen Namen. Das ist auch das Start-Beispiel des Tools.

- **Pattern:** `(?<day>\d{2})\.(?<month>\d{2})\.(?<year>\d{4})`
- **Flags:** `g`
- **Test String:**

```
Termin am 19.06.2026.
```

In **Matches** erscheinen jetzt zusätzlich zu den nummerierten Gruppen die benannten als `<day>:`, `<month>:` und `<year>:` mit ihren Werten. Im Code liest du sie später über `match.groups.day` aus — lesbarer und robuster, als sich auf Klammer-Reihenfolgen zu verlassen. Tippst du das Tool-Start-Beispiel `(?<word>\w+)` ein, siehst du 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`. Ohne `m` matcht der Anker `^` nur ganz am Stringanfang — die zweite Zeile wird nicht erfasst. Mit `m` (und `i`) passt `^` auf **jeden Zeilenanfang**, und die „fehler"-Zeile mitten im Text wird getroffen.
3. **`s` (dotall).** Pattern `Fehler.*verweigert` mit `i`. Ohne `s` matcht `.` keinen Zeilenumbruch, der Treffer kommt nicht zustande. Mit `s` darf `.` auch Newlines überspringen — der Ausdruck spannt jetzt über die Zeilengrenze hinweg.

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 — statt einer Trefferliste 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 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.

---

Noch tiefer: die [Übersicht](https://www.jpkc.com/db/tools/regex/) zum großen Bild, das [Manual](https://www.jpkc.com/db/tools/regex/manual/) für jede Funktion im Detail und die [Tipps & Tricks](https://www.jpkc.com/db/tools/regex/tips/) für Stolperfallen und Engine-Eigenheiten. Ausprobieren kannst du alles direkt im [Tool](https://www.jpkc.com/tools/regex/).