# regex — Reguläre Ausdrücke verstehen und anwenden

> Referenz zu regulären Ausdrücken: Zeichenklassen, Anker, Quantoren, Gruppen und Lookarounds — die Regex-Syntax kompakt erklärt.

Source: https://www.jpkc.com/db/cheatsheets/files-text/regex/

<!-- PROSE:intro -->
Reguläre Ausdrücke (regex) sind eine kompakte Sprache, um Muster in Text zu suchen, zu prüfen und zu ersetzen. Statt nach festen Zeichenketten zu suchen, beschreibst du mit Platzhaltern, Wiederholungen und Anker-Zeichen ganze Klassen von Treffern – etwa „vier Ziffern hintereinander" oder „eine E-Mail-Adresse". Du begegnest ihnen überall: in `grep`, `sed` und `awk` auf der Kommandozeile, in Editoren sowie in praktisch jeder Programmiersprache. Beachte dabei, dass es verschiedene Dialekte gibt – etwa BRE und ERE in den klassischen Unix-Tools oder PCRE in Perl, PHP und vielen modernen Sprachen –, weshalb sich Details bei Escapes und Erweiterungen unterscheiden können. Diese Referenz zeigt dir die Bausteine, die du in der Praxis am häufigsten brauchst.
<!-- PROSE:intro:end -->

## Zeichenklassen

`.` — Matcht ein beliebiges einzelnes Zeichen (standardmäßig außer Zeilenumbruch).

```bash
h.t matches hat, hit, hot
```

`\d` — Matcht eine beliebige Ziffer (0-9). Entspricht [0-9].

```bash
\d{3} matches 123, 456, 789
```

`\D` — Matcht ein beliebiges Nicht-Ziffer-Zeichen.

```bash
\D+ matches abc, hello
```

`\w` — Matcht ein beliebiges Wortzeichen (Buchstabe, Ziffer, Unterstrich). Entspricht [a-zA-Z0-9_].

```bash
\w+ matches hello_world, var123
```

`\W` — Matcht ein beliebiges Nicht-Wortzeichen.

```bash
\W matches !, @, spaces
```

`\s` — Matcht beliebigen Whitespace (Leerzeichen, Tab, Zeilenumbruch).

```bash
hello\sworld matches 'hello world'
```

`\S` — Matcht ein beliebiges Nicht-Whitespace-Zeichen.

```bash
\S+ matches any non-space word
```

`[abc]` — Matcht ein beliebiges Zeichen aus der Menge.

```bash
[aeiou] matches any vowel
```

`[^abc]` — Matcht ein beliebiges Zeichen, das NICHT in der Menge ist.

```bash
[^0-9] matches any non-digit
```

`[a-z]` — Matcht ein beliebiges Zeichen aus dem Bereich.

```bash
[a-zA-Z] matches any letter
```

## Quantoren

`*` — Matcht 0 oder mehr des vorangehenden Elements (gierig).

```bash
ab*c matches ac, abc, abbc, abbbc
```

`+` — Matcht 1 oder mehr des vorangehenden Elements (gierig).

```bash
ab+c matches abc, abbc but NOT ac
```

`?` — Matcht 0 oder 1 des vorangehenden Elements (optional).

```bash
colou?r matches color and colour
```

`{n}` — Matcht genau n Vorkommen.

```bash
\d{4} matches exactly 4 digits: 2026
```

`{n,}` — Matcht n oder mehr Vorkommen.

```bash
\d{2,} matches 2 or more digits
```

`{n,m}` — Matcht zwischen n und m Vorkommen.

```bash
\d{2,4} matches 12, 123, or 1234
```

`*? +? ??` — Genügsame (non-greedy) Varianten: matchen so wenig wie möglich.

```bash
<.*?> matches <b> in '<b>text</b>' (not the whole string)
```

## Anker & Grenzen

`^` — Matcht den Anfang einer Zeile/Zeichenkette.

```bash
^Hello matches 'Hello World' but not 'Say Hello'
```

`$` — Matcht das Ende einer Zeile/Zeichenkette.

```bash
world$ matches 'hello world' but not 'world hello'
```

`\b` — Matcht eine Wortgrenze (zwischen \w und \W).

```bash
\bcat\b matches 'cat' but not 'category'
```

`\B` — Matcht eine Nicht-Wortgrenze.

```bash
\Bcat\B matches 'concatenate' but not 'cat'
```

`^...$` — Matcht die gesamte Zeichenkette (kombinierte Anker).

```bash
^\d{5}$ matches only exactly 5 digits
```

## Gruppen & Alternation

`(abc)` — Erfassende Gruppe: gruppiert und erfasst für Rückbezüge.

```bash
(\d{3})-(\d{4}) captures area code and number separately
```

`(?:abc)` — Nicht-erfassende Gruppe: gruppiert ohne zu erfassen.

```bash
(?:https?://)? optionally matches http:// or https://
```

`a|b` — Alternation: matcht a ODER b.

```bash
cat|dog matches 'cat' or 'dog'
```

`\1 \2` — Rückbezug: matcht denselben Text wie eine vorherige Gruppe.

```bash
(\w+)\s\1 matches repeated words like 'the the'
```

`(?<name>abc)` — Benannte erfassende Gruppe.

```bash
(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})
```

## Lookahead & Lookbehind

`(?=abc)` — Positiver Lookahead: matcht, wenn abc folgt (ohne es zu konsumieren).

```bash
\d+(?= USD) matches '100' in '100 USD'
```

`(?!abc)` — Negativer Lookahead: matcht, wenn abc NICHT folgt.

```bash
\d+(?! USD) matches '100' in '100 EUR' but not '100 USD'
```

`(?<=abc)` — Positiver Lookbehind: matcht, wenn abc vorangeht.

```bash
(?<=\$)\d+ matches '50' in '$50'
```

`(?<!abc)` — Negativer Lookbehind: matcht, wenn abc NICHT vorangeht.

```bash
(?<!\$)\d+ matches '50' in 'EUR 50' but not '$50'
```

## Flags / Modifikatoren

`i` — Groß-/Kleinschreibung ignorieren.

```bash
/hello/i matches Hello, HELLO, hello
```

`g` — Global: alle Treffer finden, nicht nur den ersten.

```bash
/\d+/g finds all numbers in a string
```

`m` — Multiline: ^ und $ matchen Anfang/Ende jeder Zeile.

```bash
/^start/m matches 'start' at beginning of any line
```

`s` — Dotall: . matcht auch Zeilenumbruch-Zeichen.

```bash
/start.*end/s matches across multiple lines
```

## Häufige Muster

`^[\w.-]+@[\w.-]+\.[a-zA-Z]{2,}$` — E-Mail-Adresse (einfache Validierung).

```bash
user@example.com, name.tag@sub.domain.org
```

`^https?://[\w.-]+(?:/[\w./?%&=-]*)?$` — URL (HTTP/HTTPS).

```bash
https://example.com/path?q=search
```

`^\d{1,3}(?:\.\d{1,3}){3}$` — IPv4-Adresse (einfache Formatprüfung).

```bash
192.168.1.1, 10.0.0.255
```

`^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$` — Hex-Farbcode.

```bash
#fff, #1a2b3c, 00ff00
```

`^\d{4}-\d{2}-\d{2}$` — Datum im ISO-8601-Format (YYYY-MM-DD).

```bash
2026-03-19
```

`^(?=.*[A-Z])(?=.*[a-z])(?=.*\d).{8,}$` — Passwort: mind. 8 Zeichen, Groß-, Kleinbuchstabe, Ziffer.

```bash
Passw0rd, MyS3cret!
```

<!-- PROSE:outro -->
## Fazit

Reguläre Ausdrücke sind mächtig, aber sie wollen mit Bedacht eingesetzt werden. Achte zuerst auf den Dialekt: BRE, ERE und PCRE unterscheiden sich darin, welche Zeichen du escapen musst und welche Erweiterungen (etwa Lookbehind oder benannte Gruppen) überhaupt verfügbar sind – ein Muster, das in PHP läuft, scheitert unter Umständen in `grep`. Behalte außerdem den Unterschied zwischen gierigen und genügsamen Quantoren im Auge: `.*` greift standardmäßig so viel wie möglich, was oft mehr matcht als gewollt – `.*?` schafft hier Abhilfe. Und Vorsicht bei komplexen, verschachtelten Mustern mit überlappenden Quantoren: Sie können „katastrophales Backtracking" (ReDoS) auslösen und eine Engine bei bestimmten Eingaben praktisch zum Stillstand bringen. Halte Muster so einfach wie möglich und teste sie an realen Daten.

## Weiterführende Links

- [Wikipedia: Regulärer Ausdruck](https://de.wikipedia.org/wiki/Regul%C3%A4rer_Ausdruck) – deutschsprachige Einführung in Theorie und Syntax
- [regex101](https://regex101.com/) – interaktiver Online-Tester mit Erklärung (englischsprachig)
- [MDN: Reguläre Ausdrücke](https://developer.mozilla.org/de/docs/Web/JavaScript/Guide/Regular_expressions) – ausführlicher deutschsprachiger Leitfaden (JavaScript-Dialekt)
<!-- PROSE:outro:end -->

## Verwandte Kommandos

- [grep](https://www.jpkc.com/db/cheatsheets/files-text/grep/) – durchsucht Text zeilenweise nach regulären Ausdrücken
- [sed](https://www.jpkc.com/db/cheatsheets/files-text/sed/) – Stream-Editor zum Suchen und Ersetzen mit Regex
- [awk](https://www.jpkc.com/db/cheatsheets/files-text/awk/) – Muster-orientierte Textverarbeitung und -auswertung