Reguläre Ausdrücke – Grundlagen

6 Kernkonzepte

Die wichtigsten Grundlagen regulärer Ausdrücke (Regex): Metazeichen · Quantifier · Zeichenklassen · Anker · Escape-Sequenzen · Flags Reguläre Ausdrücke sind ein mächtiges Werkzeug zur Textsuche und -manipulation. Diese Grundlagen bilden die Basis für alle fortgeschrittenen Regex-Anwendungen.

Metazeichen – Die Bausteine von Regex

. · ^ · $ · * · + · ? · {} · [] · () · | · \

. // Beliebiges Zeichen (außer Zeilenumbruch) ^ // Anfang der Zeile $ // Ende der Zeile * // 0 oder mehr + // 1 oder mehr ? // 0 oder 1 (optional) {n,m} // n bis m Wiederholungen [ ] // Zeichenklasse ( ) // Gruppe / Capturing Group | // ODER (Alternation) \ // Escape-Zeichen

Metazeichen sind die Bausteine regulärer Ausdrücke. Sie haben eine spezielle Bedeutung und steuern das Suchverhalten. Um sie als Literalzeichen zu verwenden, müssen sie mit \ escaped werden.

Beispiele

# . = Beliebiges Zeichen

a.c → abc, a1c, a_c

# * = 0 oder mehr

ab*c → ac, abc, abbc, abbbc

# + = 1 oder mehr

ab+c → abc, abbc, abbbc (nicht ac)

# ? = optional

colou?r → color, colour

# | = ODER

(Hallo|Tschüss) → Hallo oder Tschüss

Tipp: Metazeichen verlieren ihre Sonderbedeutung, wenn Sie sie mit \ escapen. Beispiel: \. findet einen Punkt, \\ findet einen Backslash.

Quantifier – Wiederholungen festlegen

* · + · ? · {n} · {n,m} · {n,}

// Greedy Quantifier (standards) a* // 0 oder mehr (so viel wie möglich) a+ // 1 oder mehr (so viel wie möglich) a? // 0 oder 1 a{3} // exakt 3 a{2,5} // 2 bis 5 a{2,} // mindestens 2 // Lazy Quantifier (so wenig wie möglich) *? · +? · ?? · {n,m}?

Quantifier legen fest, wie oft ein Zeichen oder eine Gruppe wiederholt werden darf. Greedy Quantifier versuchen, so viel wie möglich zu matchen, Lazy Quantifier so wenig wie möglich.

Beispiele

# Greedy: <.*> matcht text komplett

<.*> → <tag>text</tag> (ganzer String)

# Lazy: <.*?> matcht nur

<.*?> → <tag> (nur erstes Tag)

# {n} exakte Wiederholung

\d{5} → 12345 (nur 5-stellige Zahlen)

# {n,m} Bereich

a{2,4} → aa, aaa, aaaa

Tipp: Verwenden Sie Lazy Quantifier (*?, +?, ??), wenn Sie das kleinste mögliche Match wollen – besonders wichtig bei HTML- oder XML-Parsing.

Zeichenklassen – Mengen von Zeichen

[abc] · [^abc] · [a-z] · \d · \w · \s

// Vordefinierte Zeichenklassen \d // [0-9] (Ziffer) \D // [^0-9] (Nicht-Ziffer) \w // [a-zA-Z0-9_] (Wortzeichen) \W // [^a-zA-Z0-9_] (Nicht-Wortzeichen) \s // [ \t\n\r\f\v] (Leerzeichen) \S // [^ \t\n\r\f\v] (Nicht-Leerzeichen) // Eigene Zeichenklassen [aeiou] // Vokale [^aeiou] // Konsonanten (außer Vokale) [A-Z] // Großbuchstaben [a-zA-Z] // Alle Buchstaben

Zeichenklassen definieren eine Menge von Zeichen, die an einer Position match können. Es gibt vordefinierte Klassen und selbstdefinierte Bereiche.

Beispiele

# \d = Ziffer

\d{4} → 1234, 2023, 0042

# \w = Wortzeichen (Buchstaben, Zahlen, Unterstrich)

\w+ → Hello, world_123, abc

# [A-Z] = Großbuchstaben

[A-Z][a-z]+ → Anna, Max, Julia

# Negierte Klasse

[^aeiou] → b, c, x (alles außer Vokale)

Tipp: \w ist in vielen Regex-Engines auf ASCII beschränkt. Für Unicode-Unterstützung verwenden Sie \p{L} für Buchstaben oder \p{N} für Zahlen.

Anker – Positionen im Text

^ · $ · \b · \B · (?=) · (?!) · (?<=) · (?<!)

// Zeilenanker ^ // Anfang der Zeile $ // Ende der Zeile // Wortgrenzen \b // Wortgrenze (Anfang/Ende eines Wortes) \B // Keine Wortgrenze // Lookahead / Lookbehind (Zero-Width) (?=...) // Positive Lookahead (?!) // Negative Lookahead (?<=...) // Positive Lookbehind (?<!...) // Negative Lookbehind

Anker matchen keine Zeichen, sondern Positionen im Text – den Anfang, das Ende, Wortgrenzen oder Bedingungen vor/nach einer Position.

Beispiele

# ^ = Zeilenanfang

^Hello → matcht nur "Hello" am Zeilenanfang

# $ = Zeilenende

world$ → matcht nur "world" am Zeilenende

# \b = Wortgrenze

\bcat\b → matcht "cat" aber nicht "catalog"

# Positive Lookahead

\d+(?=€) → matcht 100 in "100€" aber nicht "100$"

# Negative Lookahead

\d+(?!\d) → matcht letzte Ziffer einer Zahl

Tipp: Lookahead und Lookbehind sind "Zero-Width" – sie verbrauchen keine Zeichen beim Match. Sie sind ideal für Überprüfungen ohne Ersetzung.

Escape-Sequenzen & Flags – Sonderzeichen und Optionen

\n · \t · \r · i · g · m · s

// Escape-Sequenzen \n // Zeilenumbruch (LF) \r // Wagenrücklauf (CR) \t // Tabulator \\ // Backslash \/ // Slash (in manchen Sprachen) // Flags (Engines) i // Case-insensitive (Groß-/Kleinschreibung ignorieren) g // Global (alle Matches finden) m // Multiline (^ und $ matchen Zeilenanfang/-ende) s // DotAll (punkt matcht auch Zeilenumbruch)

Escape-Sequenzen repräsentieren Steuerzeichen und Sonderzeichen. Flags steuern das Verhalten der Regex-Engine – z.B. Groß-/Kleinschreibung oder globales Suchen.

Beispiele (JavaScript / Python)

# JavaScript: /pattern/flags

/hello/i → hello, Hello, HELLO

# Python: re.findall(pattern, text, flags)

re.findall(r'\b\w+\b', text) → Alle Wörter

# Multiline: ^ und $ matchen jede Zeile

/^Hallo/m → matcht "Hallo" am Anfang jeder Zeile

# Escape: Backslash in Regex

\\. → matcht einen Punkt (nicht jedes Zeichen)

Tipp: In den meisten Programmiersprachen müssen Sie Backslashes in Regex-Strings escapen (z.B. in Python r"\d" oder JavaScript \\d). Verwenden Sie Raw-Strings, wo möglich.

Reguläre Ausdrücke – Grundlagen im Überblick

. Beliebiges Zeichen
Außer Zeilenumbruch

\d Ziffer [0-9]
\D = Nicht-Ziffer

\w Wortzeichen [a-zA-Z0-9_]
\W = Nicht-Wortzeichen

^ $ Anfang / Ende
Mit m-Flag auch Zeilen

* + ? Quantifier
0+, 1+, optional

i g m Flags
Case-insensitiv, Global, Multiline

Quick Summary

.

Beliebiges Zeichen

*

0 oder mehr

\d

Ziffer

^

Zeilenanfang

i

Case-insensitiv

\

Escape

/\b\w+\b/g → Alle Wörter · /^\d{4}$/ → 4-stellige Zahl · /colou?r/ → color / colour