Spickzettel für reguläre Ausdrücke für Entwickler

31. März 2026 · 12 Min. Lesezeit

Einführung in reguläre Ausdrücke

Reguläre Ausdrücke (Regex) sind leistungsstarke Musterabgleichswerkzeuge, die jeder Entwickler beherrschen sollte. Sie bieten eine prägnante, deklarative Möglichkeit, Textdaten zu durchsuchen, zu validieren und zu manipulieren, ohne ausführlichen Code zur Zeichenkettenmanipulation schreiben zu müssen.

Ob Sie Formularvalidierung erstellen, Protokolldateien parsen, Daten aus APIs extrahieren oder Datensätze bereinigen – Regex bietet eine elegante Lösung. Ein einzelnes Regex-Muster kann Dutzende von Zeilen bedingter Logik ersetzen und Ihren Code wartbarer und weniger fehleranfällig machen.

Moderne Programmiersprachen wie JavaScript, Python, Java, PHP und Ruby verfügen alle über integrierte Regex-Unterstützung. Sobald Sie die Syntax gelernt haben, können Sie diese Fähigkeiten in praktisch jeder Entwicklungsumgebung anwenden.

Grundlegende Syntax und Elemente

Das Verständnis der grundlegenden Bausteine von Regex ist unerlässlich, bevor Sie komplexe Muster angehen. Diese Kernelemente bilden die Grundlage für jeden regulären Ausdruck, den Sie schreiben werden.

Literale Zeichen

Die einfachsten Regex-Muster stimmen mit literalen Zeichen genau so überein, wie sie erscheinen. Das Muster cat stimmt mit der Zeichenkette "cat" überein, wo immer sie in Ihrem Text vorkommt.

Die meisten alphanumerischen Zeichen sind literal, aber bestimmte Sonderzeichen (sogenannte Metazeichen) haben besondere Bedeutungen und müssen mit einem Backslash maskiert werden, wenn Sie sie literal abgleichen möchten.

Wesentliche Metazeichen

Maskierung von Sonderzeichen

Wenn Sie Metazeichen literal abgleichen müssen, stellen Sie ihnen einen Backslash voran. Um beispielsweise einen literalen Punkt abzugleichen, verwenden Sie \. anstatt nur .

Häufige Zeichen, die maskiert werden müssen, sind: . * + ? ^ $ { } [ ] ( ) | \

// Literales Fragezeichen abgleichen
const pattern = /What\?/;
pattern.test("What?"); // true

// Geldbetrag abgleichen
const price = /\$\d+\.\d{2}/;
price.test("$19.99"); // true

Zeichenklassen und Quantifizierer

Zeichenklassen ermöglichen es Ihnen, jedes Zeichen aus einer bestimmten Menge abzugleichen, während Quantifizierer steuern, wie oft ein Muster wiederholt werden soll. Zusammen bilden sie das Rückgrat flexibler Musterabgleichung.

Vordefinierte Zeichenklassen

Benutzerdefinierte Zeichensätze

Eckige Klammern definieren benutzerdefinierte Zeichensätze. Das Muster [aeiou] stimmt mit jedem einzelnen Vokal überein, während [0-9a-fA-F] mit jeder Hexadezimalziffer übereinstimmt.

Verwenden Sie ein Caret innerhalb der Klammern, um den Satz zu negieren: [^0-9] stimmt mit jedem Zeichen überein, das KEINE Ziffer ist.

// Jeden Vokal abgleichen
const vowels = /[aeiou]/gi;
"Hello World".match(vowels); // ["e", "o", "o"]

// Nur Konsonanten abgleichen
const consonants = /[^aeiou\s]/gi;
"Hello".match(consonants); // ["H", "l", "l"]

Quantifizierer im Detail

Quantifizierer geben an, wie oft das vorhergehende Element übereinstimmen soll. Sie sind standardmäßig gierig, was bedeutet, dass sie so viel Text wie möglich abgleichen.

• {n} - Genau n-mal: \d{4} stimmt mit genau 4 Ziffern überein
• {n,} - Mindestens n-mal: \d{3,} stimmt mit 3 oder mehr Ziffern überein
• {n,m} - Zwischen n und m-mal: \d{2,4} stimmt mit 2, 3 oder 4 Ziffern überein
• * - Null oder mehr (äquivalent zu {0,})
• + - Eins oder mehr (äquivalent zu {1,})
• ? - Null oder eins (äquivalent zu {0,1})

Anker und Wortgrenzen

Anker stimmen nicht mit Zeichen überein – sie stimmen mit Positionen in der Zeichenkette überein. Sie sind unerlässlich für präzisen Musterabgleich, wenn Sie sicherstellen müssen, dass Text an bestimmten Stellen erscheint.

Positionsanker

Das Caret ^ stimmt mit dem Anfang einer Zeichenkette (oder Zeile im Mehrzeilenmodus) überein, während das Dollarzeichen $ mit dem Ende übereinstimmt. Diese sind von unschätzbarem Wert für die Validierung, bei der die gesamte Zeichenkette mit einem Muster übereinstimmen muss.

// Validieren, dass die gesamte Zeichenkette aus Ziffern besteht
const onlyDigits = /^\d+$/;
onlyDigits.test("12345"); // true
onlyDigits.test("123abc"); // false

// Zeilen abgleichen, die mit "Error" beginnen
const errorLines = /^Error/gm;
const logs = "Info: Starting\nError: Failed\nError: Timeout";
logs.match(errorLines); // ["Error", "Error"]

Wortgrenzen

Der \b-Anker stimmt mit Wortgrenzen überein – Positionen zwischen Wort- und Nicht-Wortzeichen. Er ist perfekt zum Abgleichen ganzer Wörter, ohne versehentlich Teile größerer Wörter abzugleichen.

Der \B-Anker stimmt mit Positionen überein, die KEINE Wortgrenzen sind.

// "cat" nur als ganzes Wort abgleichen
const wholeCat = /\bcat\b/;
wholeCat.test("cat"); // true
wholeCat.test("cats"); // false
wholeCat.test("concatenate"); // false

// "cat" innerhalb von Wörtern abgleichen
const partialCat = /\Bcat\B/;
partialCat.test("concatenate"); // true
partialCat.test("cat"); // false

Wortgrenzen sind besonders nützlich für Such- und Ersetzungsoperationen, bei denen Sie Teilübereinstimmungen vermeiden möchten. Sie sind auch unerlässlich beim Erstellen von Syntax-Highlightern oder Code-Analysatoren.

Gruppen und Erfassung

Klammern in Regex dienen mehreren Zwecken: Sie gruppieren Teile von Mustern zusammen, erfassen übereinstimmenden Text zur späteren Verwendung und ermöglichen Rückverweise innerhalb des Musters selbst.

Erfassungsgruppen

Klammern erstellen nummerierte Erfassungsgruppen, die den übereinstimmenden Text speichern. Sie können diese Erfassungen in Ersetzungszeichenketten referenzieren oder sie programmatisch extrahieren.

// Datumskomponenten extrahieren
const datePattern = /(\d{4})-(\d{2})-(\d{2})/;
const match = "2026-03-31".match(datePattern);
// match[0]: "2026-03-31" (vollständige Übereinstimmung)
// match[1]: "2026" (Jahr)
// match[2]: "03" (Monat)
// match[3]: "31" (Tag)

// Datumsangaben mit Erfassungen neu formatieren
const text = "Date: 2026-03-31";
const reformatted = text.replace(/(\d{4})-(\d{2})-(\d{2})/, "$2/$3/$1");
// Ergebnis: "Date: 03/31/2026"

Nicht-erfassende Gruppen

Verwenden Sie (?:...), um Muster zu gruppieren, ohne eine Erfassung zu erstellen. Dies verbessert die Leistung und hält Ihre Erfassungsnummerierung sauber, wenn Sie nur Gruppierung für Alternation oder Quantifizierer benötigen.

// Gruppieren ohne Erfassung
const protocol = /(?:https?|ftp):\/\//;
protocol.test("https://example.com"); // true

// Vergleich mit Erfassung (unnötiger Overhead)
const protocolCapture = /(https?|ftp):\/\//;
// Erstellt eine zusätzliche Erfassungsgruppe, die wir nicht benötigen

Benannte Erfassungsgruppen

Moderne Regex-Engines unterstützen benannte Erfassungen mit der Syntax (?<name>...). Dies macht Ihre Muster selbstdokumentierend und einfacher zu warten.

// Benannte Erfassungen für Klarheit
const emailPattern = /(?<user>[\w.]+)@(?<domain>[\w.]+)/;
const match = "[email protected]".match(emailPattern);
console.log(match.groups.user); // "john.doe"
console.log(match.groups.domain); // "example.com"

// In Ersetzungen verwenden
const masked = "[email protected]".replace(
  /(?<user>[\w.]+)@(?<domain>[\w.]+)/,
  "***@$<domain>"
);
// Ergebnis: "***@example.com"

Rückverweise

Referenzieren Sie frühere Erfassungen innerhalb desselben Musters mit \1, \2 usw. Dies ist leistungsstark zum Abgleichen wiederholter oder gespiegelter Muster.

// Wiederholte Wörter abgleichen
const repeated = /\b(\w+)\s+\1\b/;
repeated.test("hello hello"); // true
repeated.test("hello world"); // false

// HTML-Tags abgleichen
const htmlTag = /<(\w+)>.*?<\/\1>/;
htmlTag.test("<div>content</div>"); // true
htmlTag.test("<div>content</span>"); // false

Regex-Flags und Modifikatoren

Flags ändern, wie die Regex-Engine Ihr Muster interpretiert. Sie werden nach dem schließenden Trennzeichen in den meisten Sprachen hinzugefügt (z.B. /pattern/flags in JavaScript).

Häufige Flags

• g (global) - Alle Übereinstimmungen finden, anstatt nach der ersten Übereinstimmung zu stoppen
• i (case-insensitive) - Groß-/Kleinschreibung beim Abgleichen von Buchstaben ignorieren
• m (multiline) - ^ und $ mit Zeilengrenzen statt Zeichenkettengrenzen abgleichen lassen
• s (dotall) - . mit Zeilenumbruchzeichen abgleichen lassen
• u (unicode) - Vollständige Unicode-Unterstützung aktivieren
• y (sticky) - Nur ab der lastIndex-Position abgleichen

// Groß-/Kleinschreibung-unabhängige Suche
const pattern = /hello/i;
pattern.test("HELLO"); // true
pattern.test("Hello"); // true

// Globales Flag für mehrere Übereinstimmungen
const digits = /\d+/g;
"Phone: 555-1234, Fax: 555-5678".match(digits);
// ["555", "1234", "555", "5678"]

// Mehrzeilenmodus
const headers = /^#.+$/gm;
const markdown = "# Title\nContent\n## Subtitle";
markdown.match(headers); // ["# Title", "## Subtitle"]

Häufige Muster und ihre Anwendungen

Lassen Sie uns bewährte Regex-Muster für häufige Entwicklungsaufgaben erkunden. Diese Muster wurden durch den Einsatz in der Praxis verfeinert und behandeln Randfälle, die Sie möglicherweise nicht zunächst in Betracht ziehen.

E-Mail-Validierung

E-Mail-Validierung ist aufgrund der RFC-Spezifikationen notorisch komplex, aber dieses praktische Muster behandelt 99% der realen E-Mail-Adressen:

const emailPattern = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;

// Gültige E-Mails
emailPattern.test("[email protected]"); // true
emailPattern.test("[email protected]"); // true

// Ungültige E-Mails
emailPattern.test("invalid@"); // false
emailPattern.test("@example.com"); // false
emailPattern.test("[email protected]"); // false

Für Produktionsanwendungen sollten Sie eine dedizierte E-Mail-Validierungsbibliothek verwenden, die internationalisierte Domains und alle RFC-Randfälle behandelt. Sie können auch unser E-Mail-Validator-Tool verwenden, um E-Mail-Muster interaktiv zu testen.

URL-Abgleich

URLs aus Text mit diesem umfassenden Muster abgleichen und extrahieren:

const urlPattern