Vollständige Referenz für reguläre Ausdrücke mit Syntax, Flags, Gruppen, Lookaheads und praxisnahen Musterbeispielen.
Im Regex-Tester ausprobieren →| Syntax | Beschreibung |
|---|---|
. | Any character except newline |
\d | Digit [0-9] |
\D | Non-digit [^0-9] |
\w | Word char [a-zA-Z0-9_] |
\W | Non-word character |
\s | Whitespace (space, tab, newline) |
\S | Non-whitespace |
[abc] | One of a, b, or c |
[^abc] | Not a, b, or c |
[a-z] | Character in range a–z |
[a-zA-Z] | Letter (any case) |
\p{L} | Any Unicode letter (u flag) |
| Syntax | Beschreibung |
|---|---|
^ | Start of string (or line with m flag) |
$ | End of string (or line with m flag) |
\b | Word boundary |
\B | Non-word boundary |
\A | Start of string (Python/Java) |
\Z | End of string (Python/Java) |
| Syntax | Beschreibung |
|---|---|
* | 0 or more (greedy) |
+ | 1 or more (greedy) |
? | 0 or 1 (optional) |
{n} | Exactly n times |
{n,} | n or more times |
{n,m} | Between n and m times |
*? | 0 or more (lazy) |
+? | 1 or more (lazy) |
?? | 0 or 1 (lazy) |
| Syntax | Beschreibung |
|---|---|
(abc) | Capturing group |
(?:abc) | Non-capturing group |
(?<name>abc) | Named capturing group |
\1 | Backreference to group 1 |
\k<name> | Named backreference |
(?|...) | Branch reset group (PCRE) |
| Syntax | Beschreibung |
|---|---|
(?=abc) | Positive lookahead — must be followed by abc |
(?!abc) | Negative lookahead — must NOT be followed by abc |
(?<=abc) | Positive lookbehind — must be preceded by abc |
(?<!abc) | Negative lookbehind — must NOT be preceded by abc |
| Flag | Name | Beschreibung |
|---|---|---|
g | Global | Find all matches, not just the first |
i | Case-insensitive | Match regardless of case (A = a) |
m | Multiline | ^ and $ match start/end of each line |
s | Dotall | . matches newline characters too |
u | Unicode | Enable full Unicode support (\p{} classes) |
y | Sticky | Match only at lastIndex position (JS) |
x | Extended | Allow whitespace + comments in pattern (Python/PHP) |
| Muster | Regex | Test |
|---|---|---|
[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,} | Im Regex-Tester ausprobieren → | |
| URL | https?:\/\/[\w\-]+(\.[\w\-]+)+[\w\-._~:/?#[\]@!$&'()*+,;=%]* | Im Regex-Tester ausprobieren → |
| IPv4 Address | \b(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\b | Im Regex-Tester ausprobieren → |
| Phone (US) | \+?1?[\s.-]?\(?\d{3}\)?[\s.-]?\d{3}[\s.-]?\d{4} | Im Regex-Tester ausprobieren → |
| Date (YYYY-MM-DD) | \d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01]) | Im Regex-Tester ausprobieren → |
| Time (HH:MM) | (?:[01]\d|2[0-3]):[0-5]\d | Im Regex-Tester ausprobieren → |
| UUID | [0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12} | Im Regex-Tester ausprobieren → |
| Hex Color | #(?:[0-9a-fA-F]{3}){1,2}\b | Im Regex-Tester ausprobieren → |
| Slug | [a-z0-9]+(?:-[a-z0-9]+)* | Im Regex-Tester ausprobieren → |
| ZIP Code (US) | \d{5}(?:-\d{4})? | Im Regex-Tester ausprobieren → |
| Credit Card | (?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13}) | Im Regex-Tester ausprobieren → |
| HTML Tag | <([a-zA-Z][a-zA-Z0-9]*)(?:\s[^>]*)?\/?>.*?<\/\1> | Im Regex-Tester ausprobieren → |
| Markdown Bold | \*\*([^*]+)\*\* | Im Regex-Tester ausprobieren → |
| JWT Token | [A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+ | Im Regex-Tester ausprobieren → |
| Semver | \bv?(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[\w.]+)?\b | Im Regex-Tester ausprobieren → |
| GitHub Username | (?<=github\.com\/)([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,37}[a-zA-Z0-9])?) | Im Regex-Tester ausprobieren → |
| Positive Integer | ^[1-9]\d*$ | Im Regex-Tester ausprobieren → |
| Float / Decimal | -?\d+(?:\.\d+)? | Im Regex-Tester ausprobieren → |
| Blank Lines | ^\s*$ | Im Regex-Tester ausprobieren → |
| Duplicate Words | \b(\w+)\s+\1\b | Im Regex-Tester ausprobieren → |
Ein regulärer Ausdruck ist eine Zeichenfolge, die ein Suchmuster definiert. Er wird für String-Suche, -Abgleich und -Manipulation verwendet. Regex wird nativ in JavaScript, Python, Java, PHP, Go und den meisten modernen Programmiersprachen unterstützt.
Gierige Quantifikatoren (*, +, {n,m}) passen auf so viele Zeichen wie möglich. Faule Quantifikatoren (*?, +?, {n,m}?) passen auf so wenige Zeichen wie möglich. Beispielsweise findet <.+> auf '<b>fett</b>' den gesamten String, während <.+?> '<b>' und '</b>' separat findet.
Lookaheads (?=...) und Lookbehinds (?<=...) sind nullbreite Zusicherungen — sie prüfen ein Muster, ohne Zeichen zu verbrauchen. Positives Lookahead (?=foo) bestätigt, dass 'foo' folgt. Negatives Lookahead (?!foo) bestätigt, dass 'foo' NICHT folgt. Sie sind äußerst nützlich für komplexe Validierungen.
Die Kernsyntax (Zeichenklassen, Quantifikatoren, Anker) ist in den meisten Sprachen konsistent. Funktionen wie Lookbehind, benannte Gruppen und spezifische Flags variieren jedoch je nach Engine. JavaScript verwendet PCRE-ähnliche Syntax ohne Lookbehind in älteren Versionen; Python, PHP und Java unterstützen vollständiges PCRE. Teste immer in deiner Zielsprache.