Reguläre Ausdrücke – Gruppen

6 Kernkonzepte

Die wichtigsten Gruppierungskonzepte in regulären Ausdrücken: Capturing Groups · Non-Capturing Groups · Named Groups · Lookaround · Backreferences · Branch Reset Gruppen sind ein zentrales Konzept in regulären Ausdrücken. Sie ermöglichen das Extrahieren von Teilstrings, bedingte Muster und komplexe Ersetzungen.

Capturing Groups – Teilstrings extrahieren

( ) · \1 · \2 · \g{1}

// Capturing Groups speichern Teilmatches (\d{4})-(\d{2})-(\d{2}) → 2024-12-31 // Gruppe 1: 2024, Gruppe 2: 12, Gruppe 3: 31 // Backreferences (auf Gruppen verweisen) (\\w+)\\s+\\1 → "hello hello", "world world"

Capturing Groups werden mit ( ) erstellt. Sie speichern den gematchten Teilstring und machen ihn über Backreferences verfügbar – ideal für Extraktion und Wiederholungsprüfungen.

Zugriff auf Gruppen

Syntax	Beschreibung	Beispiel
\1, \2, ...	Backreferenz (nur in Regex)	"(\\w+)\\s+\\1"
\g{1}, \g{2}	Backreferenz mit Nummer (Python, PCRE)	"(\\w+)\\s+\\g{1}"
\k<name>	Named Backreference	"(?<word>\\w+)\\s+\\k<word>"
$1, $2	Replacement-Referenz	replace("(\\d{4})-(\\d{2})-(\\d{2})", "$3.$2.$1")

Beispiele

# Datum extrahieren

(\d{2})/(\d{2})/(\d{4}) → 12/31/2024 (Gruppe 1: 12, 2: 31, 3: 2024)

# Backreference: doppelte Wörter finden

\b(\w+)\s+\1\b → "hello hello", "the the"

# Replacement: Datumsformat ändern

(\d{4})-(\d{2})-(\d{2}) → $3.$2.$1 (2024-12-31 → 31.12.2024)

# HTML-Tag-Inhalte extrahieren

<(\w+)>(.*?)</\1> → <title>Seite</title> (Gruppe 1: title, Gruppe 2: Seite)

Tipp: Capturing Groups sind nummeriert nach der Reihenfolge der öffnenden Klammern. Verschachtelte Gruppen werden von außen nach innen nummeriert.

Non-Capturing Groups – Gruppieren ohne Speichern

(?: ) · (?:pattern)

// Non-Capturing Groups (?:) (?:https?://)?(www\.)?\w+\.\w+ // (?: ) → Kein Backreference, kein Speicher // Vorteile: Schneller, sauberer, vermeidet Nummerierungsprobleme

Non-Capturing Groups (?: ) gruppieren Subpattern, speichern aber das Match nicht. Sie sind nützlich für Alternation, Quantifier und sauberere Regex ohne unerwünschte Backreferences.

Beispiele

# Non-Capturing für Alternation

(?:Hallo|Guten Tag) → Hallo oder Guten Tag (kein Speicher)

# Non-Capturing für Quantifier

(?:abc){2} → abcabc (nur Gruppierung, kein Speicher)

# Mit Capturing Group (Speichert nur den wichtigen Teil)

(?:https?://)?(www\.)?(\w+\.\w+) → Gruppe 1: www., Gruppe 2: domain.com

# Performance-Vorteil bei großen Datenmengen

# (?: ) ist schneller, da kein Speicher allokiert wird

Tipp: Verwenden Sie Non-Capturing Groups (?: ), wenn Sie Gruppen für Quantifier oder Alternation benötigen, aber den Inhalt nicht extrahieren wollen. Das verbessert Performance und Lesbarkeit.

Named Groups – Gruppen mit Namen versehen

(?<name>...) · \k<name>

// Named Groups mit Namen statt Nummern (?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2}) // Zugriff: \k<year>, \k<month>, \k<day> // Alternativ: (?P<name>...) in Python

Named Groups geben einer Gruppe einen aussagekräftigen Namen, was die Lesbarkeit und Wartbarkeit von komplexen Regex verbessert – besonders bei vielen Gruppen.

Beispiele

# Named Group mit Backreference

(?<word>\w+)\s+\k<word> → "hello hello"

# Named Groups für E-Mail-Extraktion

(?<user>\w+)@(?<domain>\w+\.\w+) → max@example.com

# Python: (?P<name>...)

(?P<user>\w+)@(?P<domain>\w+\.\w+)

# JavaScript: (?<name>...) (ab ES2018)

/(?<year>\d{4})-(?<month>\d{2})/

Python-Zugriff:
match.group("user") → "max"
match.group("domain") → "example.com"

Tipp: Named Groups sind besonders nützlich für komplexe Regex mit vielen Gruppen. Sie vermeiden Verwirrung durch sich ändernde Nummerierungen und machen den Code selbst-dokumentierend.

Lookaround – Bedingungen ohne Verbrauch

(?= ) · (?! ) · (?<= ) · (?<! )

// Positive Lookahead (muss folgen) \d+(?=€) → matcht 100 in "100€", nicht in "100$" // Negative Lookahead (darf nicht folgen) \d+(?!\d) → matcht letzte Ziffer einer Zahl // Positive Lookbehind (muss vorausgehen) (?<=\$)\d+ → matcht 100 in "$100", nicht in "100" // Negative Lookbehind (darf nicht vorausgehen) (?<![0-9])\d+ → Zahl ohne vorhergehende Ziffer

Lookaround (Lookahead und Lookbehind) sind Zero-Width-Assertions – sie matchen eine Position, ohne Zeichen zu verbrauchen. Sie prüfen, ob ein bestimmtes Muster vor oder nach der aktuellen Position existiert.

Lookaround-Arten

Syntax	Name	Bedeutung
(?=...)	Positive Lookahead	Muster MUSS folgen
(?!...)	Negative Lookahead	Muster DARF NICHT folgen
(?<=...)	Positive Lookbehind	Muster MUSS vorausgehen
(?<!...)	Negative Lookbehind	Muster DARF NICHT vorausgehen

Beispiele

# Positive Lookahead: Wörter vor "world"

\w+(?=\s+world) → "hello" in "hello world"

# Negative Lookahead: Wörter nicht vor "world"

\w+(?!\s+world) → "hello" in "hello test"

# Positive Lookbehind: Preis ohne Währungssymbol

(?<=\$)\d+\.\d{2} → "19.99" in "$19.99"

# Negative Lookbehind: Zahl ohne Minus

(?<!-)\d+ → "42" in "42", nicht in "-42"

# Password Validation: mindestens 8 Zeichen, eine Zahl, ein Großbuchstabe

^(?=.*[A-Z])(?=.*\d).{8,}$

Tipp: Lookbehind ((?<=...), (?<!...)) wird nicht von allen Regex-Engines unterstützt (z.B. JavaScript vor ES2018). Testen Sie Ihre Engine vor der Verwendung.

Backreferences – Auf Gruppen verweisen

\1 · \k<name> · \g{1}

// Backreferences in der Regex (\w+)\s+\1 → "hello hello" // Backreferences im Ersatztext (Replacement) $1 oder \1 → erster Gruppeninhalt // Named Backreference \k<name> → Inhalt der Named Group

Backreferences verweisen auf den Inhalt einer zuvor erfassten Gruppe – innerhalb der Regex oder im Ersatztext. Sie sind essenziell für die Erkennung von Wiederholungen und formatierte Ersetzungen.

Beispiele

# Doppelte Wörter finden

\b(\w+)\b\s+\b\1\b → "the the"

# Gleiche HTML-Tags finden

<(\w+)>.*?</\1> → <div>...</div>

# Replacement: Format ändern

(\d{2})/(\d{2})/(\d{4}) → $3-$2-$1

# Named Backreference

(?<tag>\w+)>.*?</\k<tag> → <b>text</b>

# Python: re.sub() mit Backreferences

re.sub(r'(\d{4})-(\d{2})-(\d{2})', r'\3.\2.\1', '2024-12-31') → '31.12.2024'

Tipp: In Replacement-Strings verwenden viele Engines $1 statt \1 (z.B. JavaScript, Python mit re.sub()). Prüfen Sie die Dokumentation Ihrer Sprache.

Branch Reset – Alternation mit gleicher Gruppen-Nummer

(?|...|...)

// Branch Reset: gleiche Gruppen-Nummer für Alternativen (?|(Alice)|(Bob)) → Gruppe 1 ist immer der Name // Ohne Branch Reset: (Alice)|(Bob) → Gruppe 1 oder Gruppe 2

Branch Reset (?|...|...) sorgt dafür, dass alle Alternativen in einer Gruppe die gleiche Nummer erhalten. Das vereinfacht die Extraktion bei Alternation.

Beispiele

# Ohne Branch Reset

(Alice)|(Bob) → Alice in Gruppe 1, Bob in Gruppe 2

# Mit Branch Reset

(?|(Alice)|(Bob)) → Alice oder Bob immer in Gruppe 1

# Beispiel: Datumsformate

(?|(\d{2})/(\d{2})/(\d{4})|(\d{2})-(\d{2})-(\d{4}))

# Gruppe 1 = Tag, Gruppe 2 = Monat, Gruppe 3 = Jahr, unabhängig vom Format

# Python: re.match() extrahiert immer mit gleichen Gruppen-Indizes

m = re.match(r'(?|(\d{2})/(\d{2})/(\d{4})|(\d{2})-(\d{2})-(\d{4}))', '12-31-2024')

m.group(1) → '12', m.group(2) → '31', m.group(3) → '2024'

Tipp: Branch Reset ist besonders nützlich, wenn Sie verschiedene Formate parsen (z.B. Datumsformate, Telefonnummern) und die extrahierten Teile immer an der gleichen Stelle erwarten.

Regex-Gruppen im Überblick

( ) Capturing Group
Speichert Teilstring

(?: ) Non-Capturing Group
Nur Gruppierung

(?<name>) Named Group
Mit Namen

(?= ) Positive Lookahead
Muss folgen

\1, $1 Backreferences
Auf Gruppen verweisen

(?|...) Branch Reset
Gleiche Nummerierung

Quick Summary

( )

Capturing

(?: )

Non-Capturing

(?<name>)

Named

(?= )

Lookahead

\1

Backreference

(?|...)

Branch Reset

(\d{4})-(\d{2})-(\d{2}) → Datum extrahieren · (?<word>\w+)\s+\k<word> → Doppelte Wörter