FreeToolsForWeb
HilfeSpendier mir einen Kaffee

Regex-Spickzettel — jedes Token mit Beispielen

Jedes Token regulärer Ausdrücke mit funktionierendem Beispiel, Unterstützung in JavaScript, PCRE/PHP, Python, Go, Java und .NET und einem „Ausprobieren“-Link, der den Regex-Tester vorausgefüllt öffnet.

Zuletzt geprüft: 2026-10-18, abgeglichen mit ECMAScript 2025 (MDN), PCRE2 10.45, Python 3.14 re, Go 1.27 regexp/syntax, Java 25 Pattern und der .NET-Regex-Referenz. Quellen: MDN regular expressions, PCRE2 pattern syntax, Python re, Go regexp/syntax, Java Pattern, .NET regex quick reference.

82 Einträge
Regex-Variante

✓ gleiche Syntax · ~ andere Syntax oder eingeschränkt · ✗ nicht unterstützt. Die Beispiele laufen in JavaScript; die Hinweise nennen die Syntax für andere Sprachen.

Zeichen und Escapes

Die meisten Zeichen stehen für sich selbst. Diese zwölf haben eine besondere Bedeutung und brauchen einen Backslash, um wörtlich gefunden zu werden: \ ^ $ . | ? * + ( ) [ { (und ] } an manchen Stellen).

.Beliebiges Zeichen#

Ein beliebiges einzelnes Zeichen außer einem Zeilenumbruch. Mit dem Flag s (dotAll) zählen auch Zeilenumbrüche dazu.

/h.t/g auf “hat hot h t hit h↵t” findet “hat” “hot” “h t” “hit”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
  • Python re: Schließt nur \n aus; JavaScript schließt auch \r, \u2028 und \u2029 aus.
  • Go RE2: Schließt nur \n aus.
Im Regex-Tester ausprobieren →
\. \$ \(Metazeichen escapen#

Ein Backslash macht das nächste Sonderzeichen wörtlich: \. ist ein echter Punkt, \$ ein Dollarzeichen.

/\$\d+\.\d{2}/g auf “Total $45.00, tax $3.15, tip 5” findet “$45.00” “$3.15”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
\t \n \rTabulator, Zeilenvorschub, Wagenrücklauf#

Steuerzeichen über ihren Namen. Windows-Zeilenenden sind \r\n; \r?\n findet beide Varianten.

/\w+\t\w+/g auf “name⇥age↵ana⇥31” findet “name⇥age” “ana⇥31”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
\xhhZeichen per Hex-Code#

Genau zwei Hex-Ziffern: \x41 ist A, \x20 ein Leerzeichen.

/\x41/g auf “A b A” findet “A” “A”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
\uhhhhZeichen per Unicode-Codeeinheit#

Vier Hex-Ziffern für ein Zeichen der Basic Multilingual Plane: \u00e9 ist é.

/\u00e9/g auf “café résumé” findet “é” “é” “é”
✓ JS✗ PCRE✓ Py✗ Go✓ Java✓ .NET
  • PCRE / PHP: Nutze \x{e9}.
  • Go RE2: Nutze \x{e9}.
Im Regex-Tester ausprobieren →
\u{1F600}Beliebiger Codepunkt (auch astrale)#

Codepunkt in geschweiften Klammern, nötig für Emojis und andere Zeichen oberhalb von U+FFFF. JavaScript braucht das Flag u oder v.

/\u{1F600}/gu auf “Hi 😀 there 😀” findet “😀” “😀”
✓ JS~ PCRE~ Py~ Go~ Java✗ .NET
  • PCRE / PHP: Schreibe \x{1F600} (PHP braucht den Modifikator u).
  • Python re: Schreibe \U0001F600 (acht Hex-Ziffern).
  • Go RE2: Schreibe \x{1F600}.
  • Java: Schreibe \x{1F600}.
  • .NET: Nur \uhhhh; ein Emoji besteht aus zwei UTF-16-Codeeinheiten, z. B. \uD83D\uDE00.
Im Regex-Tester ausprobieren →

Zeichenklassen

Eine Klasse findet genau ein Zeichen aus einer Menge. Innerhalb von [ ] verlieren die meisten Metazeichen ihre Bedeutung; nur bei ] \ ^ und - musst du aufpassen.

[abc]Eines von#

Ein Zeichen aus der Liste.

/gr[ae]y/g auf “gray grey groy” findet “gray” “grey”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
[^abc]Keines von#

Ein Zeichen, das nicht in der Liste steht (ein ^ an anderer als erster Stelle ist wörtlich). Findet auch Zeilenumbrüche.

/[^aeiou\s]/g auf “regex” findet “r” “g” “x”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
[a-z]Bereich#

Zeichen zwischen zwei Codepunkten. Bereiche lassen sich kombinieren: [A-Fa-f0-9] ist eine Hex-Ziffer. Ein - am Anfang oder Ende ist wörtlich.

/[A-Fa-f0-9]+/g auf “x: 3fA9 zz” findet “3fA9”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
\d \DZiffer / keine Ziffer#

\d ist eine Ziffer, \D alles andere.

/\d+/g auf “Order 66, room 101” findet “66” “101”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
  • Python re: In str-Mustern findet \d jede Unicode-Ziffer (z. B. ٣); mit re.ASCII nur 0-9.
  • .NET: Findet jede Unicode-Ziffer, sofern RegexOptions.ECMAScript nicht gesetzt ist.
Im Regex-Tester ausprobieren →
\w \WWortzeichen / Nicht-Wortzeichen#

Buchstaben, Ziffern und Unterstrich. In JavaScript und Go heißt das nur ASCII: \w findet kein é.

/\w+/g auf “snake_case and kebab-case” findet “snake_case” “and” “kebab” “case”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
  • PCRE / PHP: ASCII, außer mit PCRE2_UCP (PHP: Modifikator u plus (*UCP)).
  • Python re: In str-Mustern standardmäßig Unicode-Buchstaben und -Ziffern.
  • Java: ASCII, außer das Flag U (UNICODE_CHARACTER_CLASS) ist aktiv.
  • .NET: Unicode-Buchstaben, -Ziffern und Verbindungszeichen.
Im Regex-Tester ausprobieren →
\s \SLeerraum / kein Leerraum#

Leerzeichen, Tabulator, Zeilenumbrüche und (in den meisten Engines) weitere Unicode-Leerzeichen.

/\s+/g auf “a b⇥c” findet “ ” “⇥”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
  • Go RE2: Nur ASCII-Leerraum: \t \n \f \r und Leerzeichen.
Im Regex-Tester ausprobieren →
[[:alpha:]]POSIX-Klasse in Klammern#

Benannte Klassen wie [:alpha:], [:digit:], [:space:], [:punct:], innerhalb eckiger Klammern verwendet.

Syntax (nicht in JavaScript): [[:alpha:]]+
✗ JS✓ PCRE✗ Py✓ Go~ Java✗ .NET
  • JavaScript: Nutze [A-Za-z] oder \p{L} mit dem Flag u.
  • Java: Nutze \p{Alpha}, \p{Digit}, \p{Punct}.
[\p{L}--[a-z]]Klassen-Subtraktion / -Schnittmenge#

Mengenoperationen innerhalb einer Klasse. JavaScript braucht das Flag v (ES2024): -- subtrahiert, && bildet die Schnittmenge.

/[\p{L}--[a-z]]+/gv auf “abcÉtéXYZ” findet “É” “éXYZ”
✓ JS~ PCRE✗ Py✗ Go~ Java~ .NET
  • PCRE / PHP: Nur PCRE2 10.45+, mit der erweiterten Klassensyntax (?[ … ]).
  • Java: Schnittmenge [a-z&&[^aeiou]]; Subtraktion schreibt man als Schnittmenge mit einer Negation.
  • .NET: Subtraktion [a-z-[aeiou]]; keine Schnittmenge.
Im Regex-Tester ausprobieren →

Anker und Grenzen

Anker finden eine Position, kein Zeichen, und verbrauchen deshalb nie Text.

^ $Anfang / Ende des Strings (oder der Zeile mit m)#

Ohne das Flag m sind ^ und $ Anfang und Ende der gesamten Eingabe; mit m die jeder Zeile.

/^\w+/gm auf “first line↵second line” findet “first” “second”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
  • PCRE / PHP: $ passt auch vor einem abschließenden \n.
  • Python re: $ passt auch vor einem abschließenden \n.
  • Java: $ passt auch vor einem abschließenden Zeilenendezeichen.
  • .NET: $ passt auch vor einem abschließenden \n.
Im Regex-Tester ausprobieren →
\bWortgrenze#

Zwischen einem Wortzeichen und einem Nicht-Wortzeichen (oder dem Rand der Eingabe). Damit findest du ganze Wörter.

/\bcat\b/g auf “cat concat cats cat.” findet “cat” “cat”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
  • JavaScript: Nur ASCII-Wortzeichen, auch mit dem Flag u.
  • Go RE2: Nur ASCII-Wortzeichen.
Im Regex-Tester ausprobieren →
\BKeine Wortgrenze#

Innerhalb eines Worts, z. B. „cat“ nur, wenn es Teil eines längeren Worts ist.

/\Bcat/g auf “concat cat bobcat” findet “cat” “cat”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
\A \z \ZAbsoluter Anfang / absolutes Ende#

Anfang und Ende der Eingabe, unabhängig vom Mehrzeilenmodus. \Z erlaubt zusätzlich einen abschließenden Zeilenumbruch (außer in Python, wo es ein Synonym für \z ist).

Syntax (nicht in JavaScript): \A\d+\z
✗ JS✓ PCRE~ Py~ Go✓ Java✓ .NET
  • JavaScript: Nutze ^ und $ ohne das Flag m.
  • Python re: \A und \z (3.14+); \Z bedeutet absolutes Ende, wie \z anderswo.
  • Go RE2: \A und \z; kein \Z.
\GEnde des vorherigen Treffers#

Position, an der der letzte Treffer endete; dient zum Finden zusammenhängender Folgen.

Syntax (nicht in JavaScript): \G\d
~ JS✓ PCRE✗ Py✗ Go✓ Java✓ .NET
  • JavaScript: Kein \G; das Flag y (sticky) liefert dasselbe Verhalten „genau hier beginnen“.

Quantoren: gierig, genügsam, possessiv

Ein Quantor wiederholt das Element davor. Gierig (Standard) nimmt so viel wie möglich und gibt dann wieder ab; genügsam (mit ?) nimmt so wenig wie möglich; possessiv (mit +) gibt nie etwas ab.

*Null oder mehr#

0- bis unbegrenzt oft wiederholen.

/ba*/g auf “b ba baaa” findet “b” “ba” “baaa”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
+Eins oder mehr#

1- bis unbegrenzt oft wiederholen.

/lo+l/g auf “lol loool ll” findet “lol” “loool”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
?Optional#

Null- oder einmal.

/colou?r/g auf “color colour colouur” findet “color” “colour”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
{n}Genau n#

Genau n Wiederholungen.

/\d{3}/g auf “12 345 6789” findet “345” “678”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
{n,}n oder mehr#

Mindestens n Wiederholungen.

/\d{2,}/g auf “1 22 333” findet “22” “333”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
{n,m}Zwischen n und m#

n bis m Wiederholungen, so viele wie möglich.

/\d{2,3}/g auf “1 22 4444” findet “22” “444”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
  • Go RE2: Anzahlen über 1000 werden abgelehnt.
Im Regex-Tester ausprobieren →
{,m}Bis zu m#

Null bis m Wiederholungen. Nur manche Engines akzeptieren das; anderswo ist es der wörtliche Text „{,m}“ oder ein Fehler. {0,m} funktioniert überall.

Syntax (nicht in JavaScript): \d{,3}
✗ JS~ PCRE✓ Py✗ Go✗ Java✗ .NET
  • JavaScript: Ohne u wörtlicher Text, mit u ein Syntaxfehler; schreibe {0,3}.
  • PCRE / PHP: Nur PCRE2 10.43+.
  • Go RE2: Schreibe {0,3}.
  • Java: Schreibe {0,3}.
  • .NET: Wird als wörtlicher Text behandelt; schreibe {0,3}.
.* .+Gierig (Standard)#

Nimmt den längstmöglichen Treffer und gibt dann Zeichen zurück, bis der Rest passt. Hier verschluckt er beide Tags.

/<.+>/g auf “<b>bold</b>” findet “<b>bold</b>”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
*? +? ?? {n,m}?Genügsam (nicht gierig)#

Nimmt den kürzestmöglichen Treffer. Meist die Lösung, wenn ein Muster „zu viel findet“.

/<.+?>/g auf “<b>bold</b>” findet “<b>” “</b>”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
  • Go RE2: Auch als Flag U verfügbar, das gierig und genügsam vertauscht.
Im Regex-Tester ausprobieren →
*+ ++ ?+Possessiv#

Gierig ohne Backtracking: Einmal gefundene Zeichen werden nie zurückgegeben. Scheitert schneller und schützt vor katastrophalem Backtracking.

Syntax (nicht in JavaScript): "[^"]*+"
✗ JS✓ PCRE~ Py✗ Go✓ Java✗ .NET
  • JavaScript: Keine possessiven Quantoren oder atomaren Gruppen; nachbilden mit (?=(…))\1.
  • Python re: Python 3.11+.
  • Go RE2: Nicht nötig: RE2 macht nie Backtracking.
  • .NET: Nutze eine atomare Gruppe (?>…).

Gruppen und Rückverweise

Klammern fassen Elemente für Quantoren und Alternativen zusammen und speichern (sofern nicht als nicht erfassend markiert), was sie gefunden haben.

( … )Erfassende Gruppe#

Gruppiert und erfasst; nummeriert ab 1 nach öffnender Klammer.

/(\d{3})-(\d{4})/g auf “Call 555-0199 or 555-0123” findet “555-0199” “555-0123”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
(?: … )Nicht erfassende Gruppe#

Gruppiert, ohne zu speichern – so bleiben die Gruppennummern stabil, und das Matching ist etwas günstiger.

/(?:ab)+/g auf “ababab ab a” findet “ababab” “ab”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
(?<name> … )Benannte Gruppe#

Erfasst unter einem Namen, über den du den Wert wieder auslesen kannst (match.groups.name in JavaScript).

/(?<year>\d{4})-(?<month>\d{2})/g auf “Released 2026-10” findet “2026-10”
✓ JS✓ PCRE~ Py✓ Go✓ Java✓ .NET
  • PCRE / PHP: Auch (?'name'…) und (?P<name>…).
  • Python re: Nur (?P<name>…).
  • Go RE2: (?P<name>…); seit Go 1.22 wird auch (?<name>…) akzeptiert.
  • .NET: Auch (?'name'…).
Im Regex-Tester ausprobieren →
\1Rückverweis per Nummer#

Findet denselben Text, den eine Gruppe zuvor erfasst hat.

/(\w)\1/g auf “bookkeeper” findet “oo” “kk” “ee”
✓ JS✓ PCRE✓ Py✗ Go✓ Java✓ .NET
  • Go RE2: RE2 hat keine Rückverweise (sie würden die Garantie linearer Laufzeit brechen).
Im Regex-Tester ausprobieren →
\k<name>Rückverweis per Name#

Wie \1, aber über den Namen. Das Beispiel findet Text in passenden Anführungszeichen.

/(?<q>['"]).*?\k<q>/g auf “say "hi" or 'yo'” findet “"hi"” “'yo'”
✓ JS✓ PCRE~ Py✗ Go✓ Java✓ .NET
  • PCRE / PHP: Auch \k{name}, \g{name} und (?P=name).
  • Python re: Schreibe (?P=name).
Im Regex-Tester ausprobieren →
a|bAlternative (oder)#

Eine der beiden Seiten. Alternativen werden von links nach rechts probiert; setz also längere zuerst, wenn eine das Präfix einer anderen ist.

/cat|dog/g auf “hotdog catalog” findet “dog” “cat”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
(?> … )Atomare Gruppe#

Hat die Gruppe einmal gepasst, springt die Engine nicht per Backtracking in sie zurück.

Syntax (nicht in JavaScript): (?>a|ab)c
✗ JS✓ PCRE~ Py✗ Go✓ Java✓ .NET
  • Python re: Python 3.11+.
  • Go RE2: Nicht nötig: RE2 macht nie Backtracking.
(?i) (?i: … )Inline-Flags#

Flags innerhalb des Musters ein- oder ausschalten. (?i) gilt für den Rest des Musters; (?i:…) nur für die Gruppe; (?-i:…) schaltet ein Flag aus.

/(?i:hello) world/g auf “HELLO world HELLO WORLD” findet “HELLO world”
~ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
  • JavaScript: Nur die begrenzte Form (?i:…) / (?-i:…), für i, m und s (ES2025). (?i) am Anfang ist ein Syntaxfehler.
  • Python re: Ein globales (?i) muss ganz am Anfang des Musters stehen (anderswo seit 3.11 ein Fehler); (?i:…) funktioniert überall.
Im Regex-Tester ausprobieren →
(?(1)yes|no)Bedingung#

Findet „yes“, wenn Gruppe 1 beteiligt war, sonst „no“.

Syntax (nicht in JavaScript): (<)?\w+(?(1)>)
✗ JS✓ PCRE✓ Py✗ Go✗ Java✓ .NET
(?R) (?1)Rekursion / Subroutine#

Ruft das ganze Muster oder eine Gruppe erneut auf, für verschachtelte Strukturen wie ausgeglichene Klammern.

Syntax (nicht in JavaScript): \((?:[^()]|(?R))*\)
✗ JS✓ PCRE✗ Py✗ Go✗ Java~ .NET
  • Python re: Im externen Modul regex verfügbar.
  • .NET: Keine Rekursion; Balancing Groups (?<open-close>…) übernehmen die Verschachtelung.
(?# … )Inline-Kommentar#

Wird von der Engine ignoriert. Für längere Kommentare nutze das Flag x (extended).

Syntax (nicht in JavaScript): \d{3}(?#area code)
✗ JS✓ PCRE✓ Py✗ Go✗ Java✓ .NET

Lookahead und Lookbehind

Lookarounds prüfen, was neben der aktuellen Position steht, ohne es in den Treffer aufzunehmen. Sie haben wie Anker die Breite null.

(?= … )Positiver Lookahead#

Gefolgt von … (nicht Teil des Treffers).

/\d+(?=px)/g auf “10px 20em 30px” findet “10” “30”
✓ JS✓ PCRE✓ Py✗ Go✓ Java✓ .NET
  • Go RE2: RE2 kennt keinerlei Lookarounds.
Im Regex-Tester ausprobieren →
(?! … )Negativer Lookahead#

Nicht gefolgt von …. Das \d darin verhindert, dass die Engine Ziffern zurückgibt, nur damit die Prüfung besteht.

/\d+(?!px|\d)/g auf “10px 20em” findet “20”
✓ JS✓ PCRE✓ Py✗ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
(?<= … )Positiver Lookbehind#

Vorangestellt von … (nicht Teil des Treffers).

/(?<=\$)\d+(?:\.\d\d)?/g auf “Cost: $42.50 or 42” findet “42.50”
✓ JS~ PCRE~ Py✗ Go~ Java✓ .NET
  • JavaScript: Beliebige Länge (ES2018).
  • PCRE / PHP: Jede Alternative muss eine begrenzte Länge haben; variable Länge (standardmäßig max. 255) seit PCRE2 10.43.
  • Python re: Nur feste Breite: (?<=ab|cd) geht, (?<=a+) ist ein Fehler.
  • Java: Nur begrenzte Länge: kein * oder + darin.
  • .NET: Beliebige Länge.
Im Regex-Tester ausprobieren →
(?<! … )Negativer Lookbehind#

Nicht vorangestellt von ….

/(?<!\$)\b\d+\b/g auf “$30 and 45” findet “45”
✓ JS~ PCRE~ Py✗ Go~ Java✓ .NET
  • PCRE / PHP: Gleiche Längenregeln wie beim positiven Lookbehind.
  • Python re: Nur feste Breite.
  • Java: Nur begrenzte Länge.
Im Regex-Tester ausprobieren →
\KTrefferanfang zurücksetzen#

Entfernt alles bisher Gefundene aus dem Ergebnis; ein Lookbehind ohne Längenbegrenzung.

Syntax (nicht in JavaScript): price: \K\d+
✗ JS✓ PCRE✗ Py✗ Go✗ Java✗ .NET
  • JavaScript: Nutze (?<=…) oder eine erfassende Gruppe.

Flags (Modifikatoren)

JavaScript schreibt Flags hinter den schließenden Schrägstrich (/x/gi). Andere Sprachen übergeben Konstanten (re.I, Pattern.CASE_INSENSITIVE, RegexOptions.IgnoreCase) oder nutzen inline (?i).

gGlobal (alle Treffer)#

Findet jeden Treffer, statt beim ersten aufzuhören. Erforderlich für matchAll und replaceAll.

/o/g auf “foo boo” findet “o” “o” “o” “o”
✓ JS~ PCRE~ Py~ Go~ Java~ .NET
  • PCRE / PHP: Kein Flag: nutze preg_match_all() / preg_replace().
  • Python re: Kein Flag: nutze re.findall(), re.finditer(), re.sub().
  • Go RE2: Kein Flag: nutze die FindAll…-Methoden.
  • Java: Kein Flag: Schleife mit matcher.find().
  • .NET: Kein Flag: nutze Regex.Matches().
Im Regex-Tester ausprobieren →
iGroß-/Kleinschreibung ignorieren#

Suche ohne Beachtung der Groß-/Kleinschreibung.

/hello/gi auf “Hello HELLO hello” findet “Hello” “HELLO” “hello”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
  • Python re: re.I / re.IGNORECASE oder (?i).
  • Java: CASE_INSENSITIVE (ASCII, außer mit UNICODE_CASE) oder (?i).
  • .NET: RegexOptions.IgnoreCase oder (?i).
Im Regex-Tester ausprobieren →
mMehrzeilig#

^ und $ passen an Zeilenanfängen und -enden, nicht nur an den Enden der Eingabe.

/^-\s.+$/gm auf “- one↵- two↵three” findet “- one” “- two”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
  • Python re: re.M / re.MULTILINE.
  • .NET: RegexOptions.Multiline.
Im Regex-Tester ausprobieren →
sPunkt findet Zeilenumbruch#

Lässt . auch Zeilenumbrüche finden. Ohne das Flag ist [\s\S] das portable „alles“.

/<p>.*?</p>/gs auf “<p>a↵b</p>” findet “<p>a↵b</p>”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
  • Python re: re.S / re.DOTALL.
  • Java: Pattern.DOTALL.
  • .NET: Heißt RegexOptions.Singleline.
Im Regex-Tester ausprobieren →
xErweitert (freie Leerzeichen)#

Leerraum im Muster wird ignoriert, und # leitet einen Kommentar ein – so lassen sich lange Muster über mehrere Zeilen verteilen.

Syntax (nicht in JavaScript): (?x) \d{3} - \d{4} # local number
✗ JS✓ PCRE✓ Py✗ Go✓ Java✓ .NET
  • Python re: re.X / re.VERBOSE.
  • Java: Pattern.COMMENTS.
  • .NET: RegexOptions.IgnorePatternWhitespace.
uUnicode#

Behandelt die Eingabe als Codepunkte (sodass . ein ganzes Emoji findet), aktiviert \p{…} und \u{…} und macht ungültige Escapes zu Fehlern.

/^.$/gu auf “😀” findet “😀”
✓ JS~ PCRE~ Py~ Go~ Java~ .NET
  • PCRE / PHP: PHP-Modifikator u (UTF-8-Modus); ergänze (*UCP) für Unicode-\w und -\d.
  • Python re: Kein Flag nötig: str-Muster sind Unicode; re.ASCII schaltet das ab.
  • Go RE2: Kein Flag: Go arbeitet immer mit UTF-8-Codepunkten.
  • Java: UNICODE_CASE und UNICODE_CHARACTER_CLASS (U).
  • .NET: Kein Flag: immer UTF-16-Codeeinheiten (ein Emoji sind zwei).
Im Regex-Tester ausprobieren →
vUnicode-Mengen#

ES2024-Erweiterung von u: Mengenoperationen in Klassen (--, &&), verschachtelte Klassen und String-Eigenschaften wie \p{RGI_Emoji}. Nicht mit u kombinierbar.

/[\p{L}&&\p{ASCII}]+/gv auf “Ünïcode text” findet “n” “code” “text”
✓ JS✗ PCRE✗ Py✗ Go✗ Java✗ .NET
Im Regex-Tester ausprobieren →
ySticky#

Jeder Treffer muss genau dort beginnen, wo der vorherige endete (lastIndex). Nützlich für Tokenizer.

/\d/gy auf “12a3” findet “1” “2”
✓ JS~ PCRE~ Py✗ Go~ Java~ .NET
  • PCRE / PHP: Nutze \G.
  • Python re: Nutze pattern.match(text, pos).
  • Java: Nutze \G oder matcher.lookingAt().
  • .NET: Nutze \G.
Im Regex-Tester ausprobieren →
dTrefferindizes#

Ergänzt match.indices mit Anfang und Ende jeder erfassenden Gruppe (ES2022).

Syntax (nicht in JavaScript): /(?<y>\d{4})/d
✓ JS~ PCRE~ Py~ Go~ Java~ .NET
  • PCRE / PHP: Offsets sind immer verfügbar (PREG_OFFSET_CAPTURE).
  • Python re: Immer verfügbar: m.span(n).
  • Go RE2: Immer verfügbar: FindStringSubmatchIndex.
  • Java: Immer verfügbar: matcher.start(n) / end(n).
  • .NET: Immer verfügbar: Group.Index / Length.

Unicode-Eigenschaften \p{…}

Property-Escapes finden Zeichen nach Unicode-Kategorie oder Schrift – der einzige verlässliche Weg, „jeden Buchstaben“ sprachübergreifend zu finden. In JavaScript brauchen sie das Flag u oder v.

\p{L}Beliebiger Buchstabe#

Buchstaben jeder Schrift: é, ß, 東, д.

/\p{L}+/gu auf “naïve café 東京 123” findet “naïve” “café” “東京”
✓ JS✓ PCRE✗ Py✓ Go✓ Java✓ .NET
  • PCRE / PHP: PHP braucht für UTF-8-Eingaben den Modifikator u.
  • Python re: Nutze das externe Modul regex oder [^\W\d_] für „Buchstaben“.
Im Regex-Tester ausprobieren →
\p{Lu} \p{Ll}Groß- / Kleinbuchstabe#

Allgemeine Kategorien: Lu Großbuchstabe, Ll Kleinbuchstabe, N Zahl, P Satzzeichen, S Symbol, Z Trennzeichen.

/\p{Lu}/gu auf “Élan Vital” findet “É” “V”
✓ JS✓ PCRE✗ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
\P{…}Nicht in Eigenschaft#

Großes P negiert: \P{L} ist alles, was kein Buchstabe ist.

/\P{L}+/gu auf “abc-123” findet “-123”
✓ JS✓ PCRE✗ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
\pLKurzform mit einem Buchstaben#

Kategorien aus einem Buchstaben ohne geschweifte Klammern.

Syntax (nicht in JavaScript): \pL+
✗ JS✓ PCRE✗ Py✓ Go✓ Java✗ .NET
  • JavaScript: Geschweifte Klammern sind Pflicht: \p{L}.
  • .NET: Geschweifte Klammern sind Pflicht: \p{L}.
\p{Script=Greek}Schrift#

Zeichen eines Schriftsystems. sc= ist die Kurzform; Script_Extensions (scx=) schließt auch Zeichen ein, die sich mehrere Schriften teilen.

/\p{Script=Greek}+/gu auf “alpha α, beta β” findet “α” “β”
✓ JS~ PCRE✗ Py~ Go✓ Java✗ .NET
  • PCRE / PHP: \p{Greek}, \p{sc:Greek} oder \p{scx:Greek}.
  • Go RE2: \p{Greek}.
  • Java: Schreibe \p{script=Greek}, \p{sc=Greek} oder \p{IsGreek}.
  • .NET: Nur benannte Blöcke wie \p{IsGreek} (ein Codebereich, nicht die Schrift).
Im Regex-Tester ausprobieren →
\p{sc=Han}Chinesische Zeichen / japanische Kanji#

Han-Ideogramme. Für japanische Kana ergänze \p{sc=Hiragana} und \p{sc=Katakana}.

/\p{sc=Han}+/gu auf “Tokyo 東京 2026 中文” findet “東京” “中文”
✓ JS~ PCRE✗ Py~ Go✓ Java~ .NET
  • PCRE / PHP: \p{Han}.
  • Python re: Nutze einen Bereich wie [\u4e00-\u9fff] (deckt nur den Hauptblock ab).
  • Go RE2: \p{Han}.
  • Java: Auch \p{IsHan}.
  • .NET: Nur Blöcke, z. B. \p{IsCJKUnifiedIdeographs}.
Im Regex-Tester ausprobieren →
\p{RGI_Emoji}Emojis (ganze Sequenzen)#

Mit dem Flag v werden vollständige Emojis samt Hautfarben und Familiensequenzen gefunden. Mit u findet \p{Extended_Pictographic} nur einzelne Piktogramme.

/\p{RGI_Emoji}/gv auf “Go 👍🏽 team 👨‍👩‍👧!” findet “👍🏽” “👨‍👩‍👧”
✓ JS~ PCRE✗ Py✗ Go~ Java✗ .NET
  • PCRE / PHP: Einzelne Codepunkte über boolesche Eigenschaften in neueren PCRE2-Versionen (10.40+); keine Sequenz-Eigenschaft.
  • Java: \p{IsEmoji} findet einzelne Codepunkte (Java 21+).
Im Regex-Tester ausprobieren →
\XGraphem-Cluster#

Ein Zeichen, wie Menschen es wahrnehmen, z. B. e + kombinierender Akzent oder ein Flaggen-Emoji.

Syntax (nicht in JavaScript): \X
✗ JS✓ PCRE✗ Py✗ Go✓ Java✗ .NET
  • JavaScript: Nutze Intl.Segmenter zum Aufteilen in Grapheme.
  • Python re: Im Modul regex verfügbar.

Syntax für Ersetzungen

Was du in den Ersetzungsstring schreibst. Hier unterscheiden sich die Sprachen am stärksten, daher zählt die Spalte deiner Sprache mehr als das JavaScript-Beispiel.

$&Ganzer Treffer#

Fügt den gesamten gefundenen Text ein.

/\d+/g auf “3 apples, 12 pears” ersetzen durch “[$&]” → “[3] apples, [12] pears”
✓ JS~ PCRE~ Py~ Go~ Java✓ .NET
  • PCRE / PHP: $0 oder \0 in preg_replace.
  • Python re: \g<0>.
  • Go RE2: ${0} oder $0 (Expand / ReplaceAllString).
  • Java: $0.
  • .NET: Auch $0.
Im Regex-Tester ausprobieren →
$1Nummerierte Gruppe#

Fügt ein, was Gruppe 1 erfasst hat. Zwei Wörter vertauschen:

/(\w+)\s(\w+)/g auf “hello world” ersetzen durch “$2 $1” → “world hello”
✓ JS✓ PCRE~ Py✓ Go✓ Java✓ .NET
  • PCRE / PHP: Auch \1 und ${1}.
  • Python re: \1 oder \g<1> (nutze einen Raw-String r"\1").
  • Go RE2: Nutze ${1}x, wenn ein Buchstabe oder eine Ziffer folgt, sonst liest Go $1x als Gruppe namens „1x“.
Im Regex-Tester ausprobieren →
$<name>Benannte Gruppe#

Fügt eine benannte Gruppe ein. Ein ISO-Datum in Tag/Monat/Jahr umformatieren:

/(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})/g auf “2026-10-18” ersetzen durch “$<d>/$<m>/$<y>” → “18/10/2026”
✓ JS✗ PCRE~ Py~ Go~ Java~ .NET
  • PCRE / PHP: preg_replace kennt keine benannten Verweise; nutze die Gruppennummer oder preg_replace_callback().
  • Python re: \g<name>.
  • Go RE2: ${name} (oder $name).
  • Java: ${name}.
  • .NET: ${name}.
Im Regex-Tester ausprobieren →
$$Wörtliches Dollarzeichen#

Maskiert $ in der Ersetzung.

/(\d+)/g auf “Price: 20” ersetzen durch “$$$1” → “Price: $20”
✓ JS~ PCRE~ Py✓ Go~ Java✓ .NET
  • PCRE / PHP: Ein $, auf das weder Ziffer noch { folgt, ist schon wörtlich; schreibe danach ${1}.
  • Python re: $ ist nicht besonders; Backslashes maskierst du als \\.
  • Java: \$ (Matcher.quoteReplacement() maskiert einen ganzen String).
Im Regex-Tester ausprobieren →
$` $'Text vor / nach dem Treffer#

Fügt die Eingabe vor oder nach dem Treffer ein. Selten nötig, aber gelegentlich praktisch.

/=/ auf “key=value” ersetzen durch “ is set ($') and was ($`) ” → “key is set (value) and was (key) value”
✓ JS✗ PCRE✗ Py✗ Go✗ Java✓ .NET
Im Regex-Tester ausprobieren →

Häufige Rezepte (mit ehrlichen Einschränkungen)

Die meistgesuchten Muster, lesbar geschrieben und sicher vor katastrophalem Backtracking. Bei jedem steht, was es nicht leistet.

Email (practical)E-Mail-ähnliche Strings finden#

Lokaler Teil, @ und eine Domain mit mindestens einem Punkt.

/[\w.+-]+@[\w-]+(?:\.[\w-]+)+/g auf “Write to ana.lee+news@example.co.uk or bob@test.dev.” findet “ana.lee+news@example.co.uk” “bob@test.dev”

Einschränkung: Lehnt gültige, aber seltene Adressen ab (lokale Teile in Anführungszeichen, Nicht-ASCII-Domains) und akzeptiert manche ungültigen (a..b@x.y). Keine Regex kann dir sagen, ob ein Postfach existiert: Schick eine Bestätigungs-E-Mail.

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
URLhttp(s)-Links in Text finden#

Stoppt an Leerraum, Anführungszeichen und spitzen Klammern und lässt abschließende Satzzeichen wie Punkt oder Komma weg.

/https?://[^\s<>"]*[^\s<>".,;:!?)]/g auf “See https://example.com/a?b=1, or (http://test.dev/x).” findet “https://example.com/a?b=1” “http://test.dev/x”

Einschränkung: Gut, um Text zu verlinken, nicht zur Validierung. Zum Prüfen einer URL nutze den URL-Parser deiner Sprache (new URL() in JavaScript) und teste Protokoll und Host.

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
IPv4 addressVier Oktette 0–255#

Jedes Oktett auf 0–255 begrenzt, ohne führende Nullen.

/\b(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}\b/g auf “10.0.0.1 256.1.1.1 192.168.1.254” findet “10.0.0.1” “192.168.1.254”

Einschränkung: Deckt kein IPv6, keine CIDR-Suffixe und keine Ports ab. Zur Validierung nutze einen IP-Parser (Python ipaddress, Go net/netip, Node net.isIP).

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
Date YYYY-MM-DDKalenderdatum nach ISO 8601#

Monat 01–12 und Tag 01–31.

/\b\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])\b/g auf “2026-10-18, 2026-13-01, 2026-02-31” findet “2026-10-18” “2026-02-31”

Einschränkung: Prüft nur die Form: 2026-02-31 geht durch. Parse das Datum mit einer Datumsbibliothek, um unmögliche Tage abzulehnen.

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
Date MM/DD/YYYYUS-Datumsformat#

Monat und Tag ein- oder zweistellig, Jahr vierstellig.

/\b(?:0?[1-9]|1[0-2])/(?:0?[1-9]|[12]\d|3[01])/\d{4}\b/g auf “Due 10/18/2026 or 1/5/2027, not 13/01/2026” findet “10/18/2026” “1/5/2027”

Einschränkung: 01/02/2026 ist in den USA der 2. Januar und fast überall sonst der 1. Februar; eine Regex kann nicht wissen, was gemeint war.

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
Phone (North America)(416) 555-0199 und Varianten#

Zehn Ziffern mit optionalen Klammern, Leerzeichen, Punkten oder Bindestrichen.

/\(?\b\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g auf “(416) 555-0199, 416.555.0199, 4165550199” findet “(416) 555-0199” “416.555.0199” “4165550199”

Einschränkung: Nur nordamerikanische Nummern. Für internationale Nummern nutze eine Bibliothek wie libphonenumber; speichere Nummern im E.164-Format (nächste Zeile).

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
Phone (E.164)Internationales Format +CC…#

Ein Pluszeichen, eine Ländervorwahl, die nicht mit 0 beginnt, insgesamt bis zu 15 Ziffern.

/^\+[1-9]\d{1,14}$/gm auf “+14165550199↵+447911123456↵0044791112” findet “+14165550199” “+447911123456”

Einschränkung: Prüft die E.164-Form, nicht ob die Nummer vergeben ist oder die richtige Länge für ihr Land hat.

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
Hex colour#rgb, #rgba, #rrggbb, #rrggbbaa#

Die vier Längen, die CSS akzeptiert.

/#(?:[\da-fA-F]{8}|[\da-fA-F]{6}|[\da-fA-F]{3,4})\b/g auf “#fff #244b3f #12345 #ff000080 #1234567” findet “#fff” “#244b3f” “#ff000080”

Einschränkung: Findet auch Treffer in längerem Text, etwa in URLs mit #Fragmenten; verankere mit ^…$, um einen einzelnen Wert zu validieren.

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
URL slugkleinbuchstaben-woerter-mit-bindestrichen#

Kleinbuchstaben und Ziffern, getrennt durch einzelne Bindestriche.

/^[a-z0-9]+(?:-[a-z0-9]+)*$/gm auf “my-post-2026↵My Post↵-bad-↵good” findet “my-post-2026” “good”

Einschränkung: Nur ASCII. Um Slugs aus Titeln zu erzeugen, nutze statt einer Regex den URL-Slug-Generator.

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
Trim whitespaceLeerzeichen am Anfang und Ende#

Durch einen leeren String ersetzen. Ohne das Flag m sind ^ und $ die Enden des gesamten Texts.

/^\s+|\s+$/g auf “ padded text ” ersetzen durch “” → “padded text”

Einschränkung: Jede moderne Sprache hat ein eingebautes trim(), das schneller und klarer ist; nutze die Regex nur, wo du keinen Code aufrufen kannst (Editoren, Konfigurationsdateien).

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
Collapse spacesMehrere Leerzeichen zu einem#

Zwei oder mehr Leerzeichen oder Tabs durch ein einzelnes Leerzeichen ersetzen.

/[ \t]{2,}/g auf “too many ⇥ spaces” ersetzen durch “ ” → “too many spaces”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
Duplicate wordsthe the, is is#

Ein Wort, auf das es selbst folgt. Mit i wird auch „The the“ erkannt.

/\b(\w+)\s+\1\b/gi auf “This is is a test test of The the editor” findet “is is” “test test” “The the”

Einschränkung: Braucht Rückverweise und funktioniert daher nicht in Go. „had had“ und „that that“ sind im Englischen manchmal korrekt (im Deutschen etwa „die die“).

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
Password rulesKlein-, Großbuchstabe, Ziffer, 12+ Zeichen#

Jeder Lookahead prüft eine Regel ab dem Anfang; .{12,} legt die Länge fest.

/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{12,}$/gm auf “short1A↵alllowercase123↵GoodPassword42” findet “GoodPassword42”

Einschränkung: NIST SP 800-63B rät von Zusammensetzungsregeln ab: Verlange stattdessen eine Mindestlänge und prüfe gegen Listen geleakter Passwörter.

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
UUID8-4-4-4-12 hex#

Versionen 1–8 mit den Variant-Bits nach RFC 9562.

/\b[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\b/gi auf “id 3f2b8c1e-9d4a-4b7e-8f6a-1c2d3e4f5a6b and 00000000-0000-0000-0000-000000000000” findet “3f2b8c1e-9d4a-4b7e-8f6a-1c2d3e4f5a6b”

Einschränkung: Lehnt die Nil-UUID (nur Nullen) und die Max-UUID (nur f) ab, die gültige Sonderwerte sind.

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →
Strip HTML tags<Tags> entfernen#

Durch einen leeren String ersetzen, um groben reinen Text zu erhalten.

/<[^>]+>/g auf “<p>Hello <b>world</b></p>” ersetzen durch “” → “Hello world”

Einschränkung: Scheitert an > in Attributen, Kommentaren und Skripten und dekodiert keine Entities wie &amp;. Nie zum Bereinigen nicht vertrauenswürdigen HTMLs verwenden; nutze DOMParser oder einen Sanitizer wie DOMPurify.

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Im Regex-Tester ausprobieren →

Eine statische Referenz: Suchen und Filtern passieren in deinem Browser, und die Ausprobieren-Links öffnen unseren Regex-Tester im Browser. Alle kostenlosen Tools ansehen.

Ein Problem gefunden oder etwas, das besser sein könnte? Wir lesen jede Nachricht und beheben Fehler schnell.

Dieser Regex-Spickzettel listet jedes Token regulärer Ausdrücke auf, das du wahrscheinlich brauchst, von \d und \b bis zu Lookbehind, possessiven Quantoren und \p{Script=Greek}, jeweils mit kurzer Erklärung und einem Beispiel, das genau zeigt, was es trifft. Jedes Beispiel hat einen „Ausprobieren“-Link, der unseren Regex-Tester mit Muster, Flags und Beispieltext bereits ausgefüllt öffnet – so kannst du es ändern und zusehen, wie sich die Treffer verschieben.

Regex sieht überall gleich aus, ist es aber nicht. Lookbehind ist in JavaScript und .NET unbegrenzt, in Python auf feste Breite beschränkt, in Java und PCRE begrenzt und fehlt in Go ganz. Python schreibt benannte Gruppen als (?P<name>…), PHP kann in einer Ersetzung keine Namen verwenden, und nur manche Engines kennen \A, \K oder (?R). Die Varianten-Auswahl zeigt die Unterstützung jedes Tokens in JavaScript, PCRE/PHP, Python, Go, Java und .NET, mit der alternativen Syntax, wo es eine gibt. Die Beispiele selbst laufen in JavaScript; für die anderen Sprachen lies die Hinweise und teste in der jeweiligen Sprache, bevor du etwas auslieferst.

So funktioniert’s

  1. Suche nach einem Token (\b, Lookahead) oder einer Aufgabe (E-Mail, Trimmen, doppelte Wörter) oder springe über die Chips oben zu einem Abschnitt.
  2. Wähle deine Sprache in der Variantenleiste. Tokens, die sie nicht unterstützt, werden abgeblendet, und der Hinweis unter jedem Eintrag nennt die Syntax, die deine Sprache stattdessen verwendet.
  3. Klicke auf „Im Regex-Tester ausprobieren“, um das Beispiel live auszuführen, und bearbeite dort Muster oder Text.
  4. Nutze das # neben einem Eintrag, um direkt darauf zu verlinken, oder „Drucken / Als PDF speichern“ für eine kompakte zweispaltige Fassung.

Häufige Fragen

Was ist der Unterschied zwischen gierigen und genügsamen Quantoren?

Ein gieriger Quantor (*, +, {n,m}) nimmt so viele Zeichen wie möglich und gibt einige zurück, wenn der Rest des Musters scheitert; ein genügsamer (*?, +?, {n,m}?) nimmt so wenige wie möglich. Bei <b>bold</b> trifft <.+> den ganzen String, während <.+?> <b> und </b> einzeln trifft. Possessive Quantoren (*+, ++) sind gierig und geben nie Zeichen zurück; JavaScript, Go und .NET haben sie nicht.

Welche Sprachen unterstützen Lookbehind?

JavaScript (seit ES2018) und .NET erlauben Lookbehind beliebiger Länge. Java verlangt eine begrenzte Maximallänge, also kein * oder + darin. Das re-Modul von Python akzeptiert nur Lookbehind mit fester Breite. PCRE2 verlangte bis 10.43, dass jede Alternative eine feste Länge hat; mit 10.43 kam Lookbehind variabler Länge bis zu einem Limit (standardmäßig 255 Zeichen). Die RE2-Engine von Go hat überhaupt kein Lookahead oder Lookbehind.

Wie treffe ich jeden Buchstaben, auch Buchstaben mit Akzent und nicht-lateinische?

Verwende die Unicode-Eigenschaft \p{L}. In JavaScript braucht sie das Flag u oder v (/\p{L}+/u); PCRE, Go, Java und .NET unterstützen sie direkt. [a-zA-Z] verfehlt é, ß und jede nicht-lateinische Schrift, und \w ist in JavaScript und Go nur ASCII. Das eingebaute re von Python hat kein \p{…}; nimm das Drittanbieter-Modul regex oder [^\W\d_], das in Python 3 Unicode-Buchstaben trifft.

Wie verwende ich eine gefangene Gruppe in der Ersetzung?

Das hängt von der Sprache ab: $1 in JavaScript, Java, .NET, Go und PHP; \1 oder \g<1> in Python. Benannte Gruppen sind $<name> in JavaScript, ${name} in Java, .NET und Go und \g<name> in Python; preg_replace von PHP hat keine benannte Form, nimm also die Nummer. Der gesamte Treffer ist $& in JavaScript und .NET, $0 in Java und PHP und \g<0> in Python.

Warum funktioniert meine Regex in JavaScript, aber nicht in Python (oder umgekehrt)?

Die üblichen Verdächtigen: benannte Gruppen ((?<name>) in JavaScript, (?P<name>) in Python), \p{…}-Eigenschaften (JavaScript ja, Python re nein), Lookbehind-Länge (beliebig in JavaScript, fest in Python), Inline-Flags ((?i) am Anfang funktioniert in Python, ist in JavaScript aber ein Fehler, das nur das begrenzte (?i:…) kennt) und \d oder \w, die in Python Unicode-Ziffern und -Buchstaben treffen, in JavaScript aber nur ASCII. Denk außerdem an das Escaping in Python-Strings: Schreib Muster als Raw-Strings, r"\d+".

Ist es sicher, E-Mail-Adressen mit einer Regex zu validieren?

Nur als Formprüfung. Ein praxistaugliches Muster wie [\w.+-]+@[\w-]+(?:\.[\w-]+)+ fängt Tippfehler ab, lehnt aber manche gültigen Adressen ab (lokale Teile in Anführungszeichen, internationalisierte Domains) und akzeptiert manche ungültigen. Kein Muster kann dir sagen, dass ein Postfach existiert – prüfe die Form also locker und schick dann eine Bestätigungs-E-Mail.

Muster schreiben, die in mehr als einer Sprache funktionieren

Wenn ein Muster in mehreren Engines laufen muss (eine gemeinsame Validierungsregel, eine Konfigurationsdatei, die von Diensten in verschiedenen Sprachen gelesen wird), bleib in der gemeinsamen Teilmenge. Diese Elemente verhalten sich in allen sechs Engines auf dieser Seite gleich:

• Literale Zeichen, Escapes wie \. und \$ sowie die Klassen [abc], [^abc] und [a-z].

• \d, \s und \w, solange deine Eingabe ASCII ist (Python und .NET treffen auch Unicode-Ziffern und -Buchstaben).

• ^ und $, \b, Alternation, fangende und nicht fangende Gruppen.

• Gierige und genügsame Quantoren: *, +, ?, {n}, {n,m} und ihre ?-Formen.

Lass Lookaround weg (Go hat keins), Rückverweise (Go), possessive Quantoren und atomare Gruppen (JavaScript, Go und .NET fehlt eines oder beides), benannte Gruppen (die Syntax von Python weicht ab) und \p{…} (dem re von Python fehlt es). Wenn du eines davon brauchst, halte eine Fassung des Musters pro Sprache vor und teste jede.

Katastrophales Backtracking vermeiden

Backtracking-Engines (JavaScript, PCRE, Python, Java, .NET) können exponentiell lange brauchen bei Mustern, in denen eine quantifizierte Gruppe denselben Text auf viele Arten treffen kann, etwa (a+)+$ oder (\w|\d)*x. Bei einer langen Eingabe, die fast passt, probiert die Engine vor dem Scheitern jede Aufteilung aus, und ein Webserver kann an einer einzigen Anfrage hängen bleiben. Das ist das Problem des Regular Expression Denial of Service (ReDoS).

Die Lösungen sind mechanisch: Vermeide verschachtelte Quantoren über dieselben Zeichen; mach Alternativen gegenseitig ausschließend; nimm eine negierte Klasse wie [^"]* statt .*?, wenn du das Trennzeichen kennst; verwende possessive Quantoren oder atomare Gruppen, wo deine Engine sie hat; und begrenze die Eingabelänge vor dem Matching. .NET bietet außerdem RegexOptions.NonBacktracking und ein Match-Timeout, PCRE hat einstellbare Match-Limits, und die RE2-Engine von Go garantiert lineare Laufzeit, indem sie die Features, die Backtracking brauchen, gar nicht erst unterstützt.

Regex in Strings escapen

Die meisten Regex-Fehler in echtem Code sind Escaping-Fehler in Strings, keine Regex-Fehler. Der Backslash ist sowohl für das String-Literal der Sprache als auch für die Regex-Engine ein Sonderzeichen, ein als normaler String geschriebenes Muster braucht also doppelte Backslashes.

• JavaScript: Ein Literal /\d+/ braucht einen Backslash; new RegExp("\\d+") braucht zwei. String.raw`\d+` vermeidet die Verdopplung.

• Python: Verwende immer Raw-Strings, r"\d+"; sonst ist "\b" ein Backspace-Zeichen und keine Wortgrenze.

• Java und C#: "\\d+" in normalen Strings (auch Java-Textblöcke verarbeiten Escapes); C#-Verbatim-Strings, @"\d+", behalten Backslashes so, wie sie getippt wurden.

• Go: Raw-Strings in Backticks, `\d+`, sind mit regexp.MustCompile die Norm.

• PHP: Muster enthalten Begrenzer, '/\d+/', und Strings in einfachen Anführungszeichen behalten die meisten Backslashes so, wie sie getippt wurden.

Ähnliche kostenlose Tools

  • Regex-Tester — Teste einen regulären Ausdruck an Beispieltext mit Live-Hervorhebung der Treffer, Capture Groups und Vorschau fürs Ersetzen. Kostenlos, im Browser.
  • Git-Spickzettel — Git-Befehle geordnet nach dem, was du tun willst: letzten Commit rückgängig machen, Branch umbenennen, Remote-Branch löschen. Modernes switch/restore mit klassischen Entsprechungen und Warnhinweisen.
  • Markdown-Spickzettel — Jedes Markdown-Element mit Quelltext und gerenderter Vorschau, erweiterte Syntax (Tabellen, Aufgabenlisten, Fußnoten, Mathematik, Mermaid, Hinweisboxen), eine Kompatibilitätstabelle für 9 Plattformen und ein Live-Playground.
  • Cron-Generator — Erstelle einen Cron-Zeitplan per Dropdown oder füge einen ein, lies ihn in Klartext und sieh die nächsten 10 Ausführungen in deiner Zeitzone und in UTC. Kostenlos, im Browser.
  • Diff-Checker — Vergleiche zwei Versionen eines Textes, Codes oder einer JSON-Datei und sieh genau, welche Zeilen, Wörter und Zeichen sich geändert haben.