Reguläre Ausdrücke erklärt: Muster, Gruppen & echte Beispiele

Regex sieht aus wie Tastaturrauschen — \d{3}-\d{4} —, ist aber eine kleine Sprache zur Beschreibung von Text. Lerne die Bausteine, wie die Engine wirklich abgleicht, und die Muster, die sich zu merken lohnen.

📂 Grundlagen für Entwickler ⏱ Etwa 14 Minuten 📶 Fortgeschritten 🛠️ Passt zu: Regex-Tester

Was du lernen wirst

  • Lies eine Regex laut vor und sage, was sie matcht
  • Nutze Zeichenklassen, Quantoren, Anker und Gruppen mit Selbstvertrauen
  • Weiß, wann gieriges Matching zubeißt — und wie Lazy Matching es behebt
  • Schreibe Muster für E-Mails, Daten, Telefonnummern und Log-Zeilen
  • Erkenne die Muster, die ein Programm einfrieren (katastrophales Backtracking)
In diesem Guide
  1. Was ein regulärer Ausdruck ist
  2. Die Bausteine
  3. Wie die Engine wirklich matcht: gierig, lazy und Backtracking
  4. Muster, die sich zu merken lohnen
  5. Flags: die Schalter, die alles verändern
  6. Häufige Fehler
  7. Ausprobieren: Regex-Tester
  8. Häufige Fragen

Was ein regulärer Ausdruck ist

A regulärer Ausdruck (Regex) ist ein Muster, das eine Menge von Strings beschreibt. Statt Code zu schreiben, der sagt „prüfe jedes Zeichen einzeln“, schreibst du eine kompakte Beschreibung — \d{3}-\d{4} — und fragst dich: Enthält dieser Text etwas, das so geformt ist?

Regexes gibt es überall: Suchen in einem Editor, Validieren eines Formulars, Umbenennen von tausend Dateien, Parsen eines Logs, Hervorheben von Treffern auf einer Seite. Sie sind keine eigene Programmiersprache, aber fast jede Sprache bettet dieselbe Kernsyntax ein — lerne sie einmal und sie begleitet dich von JavaScript über Python bis zur Kommandozeile.

Der Haken ist die Lesbarkeit. Regex ist berühmt dafür, nur zum Schreiben zu sein: Ein Muster, das du letzten Monat geschrieben hast, kann heute wie Zeilenrauschen aussehen. Die Lösung ist nicht, Regex zu vermeiden, sondern Muster aus kleinen, benannten Bausteinen zu bauen und sie zu testen — genau dafür sind dieser Guide und der zugehörige Tester da.

Die Bausteine

Fast jedes Muster ist aus diesen Bausteinen zusammengesetzt:

BausteinBedeutungBeispiel
abcLiterale Zeichenmatcht abc genau
.Ein beliebiges einzelnes Zeichen (außer Zeilenumbruch)a.c matcht abc, a-c
\d \w \sZiffer, Wortzeichen, Whitespace\d matcht 7
\D \W \SDie Gegenteile (keine Ziffer usw.)\D matcht a
[abc] [a-z] [^0-9]Zeichenklasse / negierte Klasse[aeiou] matcht einen Vokal
* + ? {n} {n,m}Quantoren: 0+, 1+, 0/1, genau n, n bis m\d{3} matcht drei Ziffern
^ $ \bAnker: Anfang, Ende, Wortgrenze^cat matcht nur am Anfang
( ) (?: ) (?<name> )Capturing-Gruppe, Non-Capturing-Gruppe, benannte Gruppe(\d+)-(\d+) erfasst zwei Zahlen
|Alternative (oder)cat|dog matcht eines von beiden
\Escape: macht ein Sonderzeichen literal\. matcht einen echten Punkt

Zwei Bausteine verursachen die meisten Anfängerfehler. Erstens: . ist speziell — um einen literalen Punkt in example.com musst du schreiben example\.com, sonst matcht dein Muster auch exampleXcom. Zweitens: Eine Zeichenklasse [.] braucht innerhalb der eckigen Klammern kein Escaping — die meisten Zeichen verlieren dort ihre Magie.

Wie die Engine wirklich matcht: gierig, lazy und Backtracking

Eine Regex-Engine liest dein Muster von links nach rechts und versucht, Schritt für Schritt zu matchen. Wenn sie auf einen Quantor wie .* ist er gierig standardmäßig: Er nimmt so viel wie möglich und gibt dann Zeichen einzeln zurück, bis der Rest des Musters passt. Dieser Prozess — versuchen, scheitern, zurückgeben — heißt Backtracking.

<p>first</p> <p>second</p>
Pattern: <p>.*</p>      → matches the WHOLE line (greedy)
Pattern: <p>.*?</p>     → matches <p>first</p> only (lazy)

Hinzufügen von ? nach einem Quantor macht ihn lazy: so wenig wie möglich matchen. Gierig ist die richtige Voreinstellung für „alles bis zum Ende“; lazy ist die richtige Voreinstellung für „das nächste schließende Tag“. Eine falsche Wahl ist der häufigste Grund, warum ein Muster viel mehr (oder viel weniger) matcht als erwartet.

Katastrophales Backtracking. Ein Muster wie (a+)+$ auf einem langen String aus a's kann praktisch ewig dauern: Die Engine probiert exponentiell viele Möglichkeiten, dieselben Zeichen aufzuteilen. Die Regel: Verschachtele niemals Quantoren über sich überschneidende Alternativen und bevorzuge ein spezifisches Muster ([^<]*) gegenüber einem vagen (.*) innerhalb einer wiederholten Gruppe.

Muster, die sich zu merken lohnen

Nimm diese als Ausgangspunkte — teste jedes gegen deine echten Daten, bevor du es auslieferst:

# A simple email check (good enough for a form hint, not proof)
\b[\w.+-]+@[\w-]+\.[\w.]+\b

# Date: YYYY-MM-DD
^\d{4}-\d{2}-\d{2}$

# North American phone number, flexible separators
^\+?1?[-. ]?\(?\d{3}\)?[-. ]?\d{3}[-. ]?\d{4}$

# A word, with its position: capture the username from user@host
^(?<user>[\w.+-]+)@(?<host>[\w-]+\.[\w.]+)$

# Lines starting with ERROR in a log file (multiline flag m)
^ERROR: (.*)$

Beachte, dass das E-Mail-Muster absichtlich unvollkommen ist: Der echte Standard für E-Mail-Adressen ist so kompliziert, dass eine einzige Regex für „alle gültigen E-Mails“ hunderte Zeichen lang und trotzdem falsch wäre. Der professionelle Ansatz ist eine einfache Plausibilitätsprüfung plus das tatsächliche Senden einer Bestätigungs-E-Mail.

Flags: die Schalter, die alles verändern

FlagEffekt
gGlobal — findet alle Matches, nicht nur den ersten
iGroß-/Kleinschreibung egal — cat matcht CAT
mMehrzeilig — ^ und $ matchen an Zeilenanfängen und -enden
sDot-All — . matcht auch Zeilenumbrüche
uUnicode-Modus — korrekte Behandlung von Emojis und astralen Zeichen

Das m Flag überrascht die Leute am meisten: Ohne es ^ERROR matcht nur ganz am Anfang des gesamten Textes, nicht am Anfang jeder Zeile in einer Log-Datei. Wenn dein Muster in einer Zeile funktioniert, aber nicht in einer Datei, ist das fehlende m das Erste, was du prüfen solltest.

Häufige Fehler

  • Verwenden von .* wenn du meinst [^<]* oder \S+. Vage Muster backtracken und matchen zu viel; spezifische sind schneller und sicherer.
  • Vergessen zu escapen ., (, + in literalen Text. file.txt als Muster matcht auch fileatxt.
  • E-Mails mit einer einzigen riesigen Regex validieren. Nutze eine einfache Prüfung und verifiziere dann per E-Mail.
  • HTML oder verschachtelte Strukturen mit Regex parsen. HTML ist keine reguläre Sprache — ein Parser ist das richtige Tool, und Regex bricht am ersten verschachtelten Tag.
  • Verschachtelte Quantoren wie (a+)+ oder (.*)*. Der klassische Freeze. Schreibe es mit einem einzigen Quantor über einer präzisen Klasse neu.
  • Vergessen des g Flags. In vielen Tools wird nur der erste Match zurückgegeben, es sei denn, du fragst nach allen.

Ausprobieren: Regex-Tester

Jedes Muster in diesem Guide ist testbar: Füge es in den Regex-Tester ein, tippe deinen eigenen Text darunter und sieh zu, wie die Matches live hervorgehoben werden — mit jeder Capture-Gruppe aufgelistet.

Regex-Tester öffnen →

Weiterlernen

Häufige Fragen

Welche Regex-Variante soll ich lernen?

Die Kernsyntax ist fast überall dieselbe. JavaScript, Python, Java und Go stimmen bei den Grundlagen in der Tabelle oben überein; sie unterscheiden sich an den Rändern (Lookbehind, Syntax benannter Gruppen, Unicode-Behandlung). Lerne den Kern und prüfe dann die Doku deiner Sprache für die Ränder — und teste im Regex-Tester, der die JavaScript-Engine deines Browsers nutzt.

Was ist eine Capture-Gruppe und wozu brauche ich sie?

Klammern haben zwei Aufgaben: Sie gruppieren einen Teil eines Musters und erfassen standardmäßig auch, was sie gematcht haben, sodass du es wiederverwenden kannst — zum Beispiel, um 2026-11-21 mit einer Ersetzung wie $3/$2/$1 in 21/11/2026 zu verwandeln. Nutze (?:…), wenn du nur Gruppierung brauchst und die Erfassung nicht willst.

Warum ist meine Regex langsam oder friert die Seite ein?

Fast immer katastrophales Backtracking: verschachtelte Quantoren über sich überschneidende Alternativen bei langem Input. Vereinfache das Muster, ersetze .* durch eine negierte Klasse oder füge einen Anker hinzu, damit die Engine schnell scheitert, statt jede Aufteilung zu probieren.

Was ist der Unterschied zwischen * und +?

* bedeutet „null oder mehr“ — der Baustein darf ganz fehlen. + bedeutet „eins oder mehr“ — er muss mindestens einmal vorkommen. \d* matcht einen leeren String; \d+ nicht. Dieser Unterschied von einem Zeichen ist eine häufige Ursache für Muster, die matchen, obwohl sie es nicht sollten.

Kann Regex eine E-Mail-Adresse richtig validieren?

Keine einzige praktikable Regex deckt den vollen Standard ab — Strings in Anführungszeichen, Kommentare und ungewöhnliche Domains machen sie absurd lang. Ein kurzes Muster plus eine Bestätigungs-E-Mail ist die professionelle Antwort; die Regex ist ein Tippfehler-Fänger, kein Beweis.