Regex

Regex (Regular Expression, deutsch: regulärer Ausdruck) ist eine spezialisierte Syntax zur Beschreibung von Suchmustern in Zeichenketten. Mit Regex kannst du komplexe Textmuster definieren, um Strings zu durchsuchen, zu validieren oder zu manipulieren. Regex ist ein universelles Werkzeug, das in praktisch allen modernen Programmiersprachen und vielen Texteditoren verfügbar ist.

Geschichte und Entwicklung

Die Ursprünge von Regular Expressions liegen überraschenderweise nicht in der Informatik, sondern in der Neurowissenschaft. 1943 entwickelten Warren S. McCulloch und Walter Pitts Modelle zur Beschreibung der Funktionsweise des menschlichen Nervensystems. Der Mathematiker Stephen Kleene formalisierte diese Erkenntnisse 1956 mit einer Algebra-Notation, die er “Regular Expressions” nannte.

Der Durchbruch für die praktische Anwendung kam 1968, als der Unix-Pionier Ken Thompson Regular Expressions in den Texteditor ed implementierte. In den 1980er Jahren popularisierte die Programmiersprache Perl Regex und machte sie für eine breitere Entwickler-Community zugänglich. Heute werden Regex in über einem Drittel aller Python- und JavaScript-Projekte eingesetzt.

Grundlegende Syntax

Regular Expressions bestehen aus normalen Zeichen und sogenannten Metazeichen, die eine spezielle Bedeutung haben. Die wichtigsten Elemente sind:

Metazeichen

Zeichenklassen

Zeichenklassen definieren eine Menge von Zeichen, die an einer bestimmten Position passen können:

[abc]       - Eines der Zeichen a, b oder c
[a-z]       - Kleinbuchstabe von a bis z
[A-Z]       - Großbuchstabe von A bis Z
[0-9]       - Ziffer von 0 bis 9
[^abc]      - Jedes Zeichen außer a, b, c (negiert)

# Kurzschreibweisen
\d          - Ziffer (entspricht [0-9])
\D          - Keine Ziffer
\w          - Wortzeichen (Buchstaben, Ziffern, Unterstrich)
\W          - Kein Wortzeichen
\s          - Whitespace (Leerzeichen, Tab, Zeilenumbruch)
\S          - Kein Whitespace
\b          - Wortgrenze

Quantifizierer

Quantifizierer bestimmen, wie oft ein Element vorkommen darf:

Gruppen und Referenzen

Klammern () definieren Gruppen, die mehrere Zeichen zusammenfassen und deren Inhalt erfassen:

# Erfassungsgruppen
(abc)           - Gruppe, die "abc" erfasst
(\d{3})-(\d{4}) - Zwei Gruppen für Telefonnummern

# Rückreferenzen
\1, \2          - Verweis auf erste/zweite Gruppe
(\w+)\s+\1      - Findet doppelte Wörter wie "das das"

# Nicht-erfassende Gruppen
(?:abc)         - Gruppiert ohne zu erfassen (performanter)

# Benannte Gruppen (moderne Syntax)
(?<name>\w+)    - Benannte Gruppe "name"

Regex in verschiedenen Programmiersprachen

Python

import re

# Einfache Suche
text = "Die Telefonnummer ist 030-12345678"
pattern = r'\d{3}-\d{8}'
match = re.search(pattern, text)
if match:
    print(f"Gefunden: {match.group()}")  # 030-12345678

# Alle Treffer finden
text = "E-Mails: max@firma.de und anna@schule.de"
pattern = r'\w+@\w+\.\w+'
matches = re.findall(pattern, text)
print(matches)  # ['max@firma.de', 'anna@schule.de']

# Suchen und Ersetzen
text = "Hallo Max, hallo Anna"
result = re.sub(r'[Hh]allo', 'Hi', text)
print(result)  # Hi Max, Hi Anna

JavaScript

// Regex-Literal
const regex = /\d{3}-\d{8}/;
const text = "Tel: 030-12345678";

// Überprüfung
console.log(regex.test(text));  // true

// Treffer mit exec
const match = regex.exec(text);
console.log(match[0]);  // 030-12345678

// Alle Treffer mit match (globales Flag g)
const str = "abc123xyz456";
const pattern = /\d+/g;
console.log(str.match(pattern));  // ['123', '456']

// Ersetzen
const result = str.replace(/\d+/g, '***');
console.log(result);  // abc***xyz***

Java

import java.util.regex.Pattern;
import java.util.regex.Matcher;

String text = "E-Mail: max@beispiel.de";
String patternString = "\\w+@\\w+\\.\\w+";

Pattern pattern = Pattern.compile(patternString);
Matcher matcher = pattern.matcher(text);

if (matcher.find()) {
    System.out.println("Gefunden: " + matcher.group());
}

// Case-insensitive Suche
Pattern ciPattern = Pattern.compile("hello", 
    Pattern.CASE_INSENSITIVE);

PHP

<?php
$text = "Kontakt: info@firma.de";
$pattern = '/\w+@\w+\.\w+/';

// Einzelner Treffer
if (preg_match($pattern, $text, $matches)) {
    echo "Gefunden: " . $matches[0];
}

// Ersetzen
$result = preg_replace('/\d+/', '***', "Tel: 12345");
echo $result;  // Tel: ***

// Case-insensitive mit i-Flag
$pattern = '/hello/i';
?>

Praktische Anwendungsbeispiele

E-Mail-Validierung

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

Dieses Pattern prüft:

• Lokaler Teil: Buchstaben, Ziffern und bestimmte Sonderzeichen
• @-Symbol
• Domain: Buchstaben, Ziffern, Punkte und Bindestriche
• TLD: Mindestens 2 Buchstaben

Passwort-Validierung

^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*\W).{8,16}$

Prüft auf:

• Mindestens eine Ziffer (?=.*[0-9])
• Mindestens ein Kleinbuchstabe (?=.*[a-z])
• Mindestens ein Großbuchstabe (?=.*[A-Z])
• Mindestens ein Sonderzeichen (?=.*\W)
• Länge zwischen 8 und 16 Zeichen

URL-Erkennung

https?:\/\/[\w.-]+(?:\.[a-z]{2,})+(?:[\/\w.-]*)*\/?(?:\?[\w=&-]*)?(?:#[\w-]*)?

Erkennt URLs mit:

• HTTP oder HTTPS Protokoll
• Domain mit Subdomains
• Optionaler Pfad
• Optionale Query-Parameter
• Optionaler Anker

Datum im deutschen Format

^(0[1-9]|[12][0-9]|3[01])\.(0[1-9]|1[0-2])\.(19|20)\d{2}$

Validiert Datumsangaben wie “06.12.2025” mit:

• Tag: 01–31 (vereinfacht)
• Monat: 01–12
• Jahr: 1900–2099

Performance und Best Practices

Bei der Arbeit mit Regex gibt es einige wichtige Aspekte zu beachten:

Gieriges vs. Faulen Matching

Standardmäßig sind Quantifizierer gierig (greedy). Sie versuchen, so viele Zeichen wie möglich zu erfassen:

# Gierig: <.*> auf "<div>Text</div>" erfasst alles
<.*>          -> "<div>Text</div>"

# Faul (mit ?): Erfasst so wenig wie möglich
<.*?>         -> "<div>" (nur das erste Tag)

Katastrophales Backtracking vermeiden

Verschachtelte Quantifizierer können zu exponentieller Laufzeit führen:

# SCHLECHT: Kann extrem langsam werden
(a+)+b

# BESSER: Flache Struktur
a+b

Weitere Best Practices

• Anker verwenden: Mit ^ und $ wird nur am Anfang/Ende gesucht
• Spezifische Zeichenklassen: [a-z0-9] statt . wenn möglich
• Pattern kompilieren: Bei mehrfacher Verwendung vorher kompilieren
• Kommentare nutzen: Mit dem x-Flag kannst du Patterns lesbar formatieren
• Online-Tools testen: Nutze regex101.com zum Debuggen

Häufige Fehler

Regex in der IT-Praxis

Regular Expressions sind in vielen Bereichen der IT unverzichtbar:

• Formularvalidierung: E-Mails, Telefonnummern, Postleitzahlen prüfen
• Log-Analyse: Fehlermeldungen und Muster in Logdateien finden
• Datenbereinigung: Unerwünschte Zeichen entfernen, Formate vereinheitlichen
• Code-Refactoring: Variablen umbenennen, Patterns ersetzen
• Web Scraping: Daten aus HTML-Seiten extrahieren
• Sicherheit: Input-Validierung gegen SQL-Injection und XSS

Als angehender Fachinformatiker für Anwendungsentwicklung wirst du Regex regelmäßig in der Backend- und Frontend-Entwicklung einsetzen. Auch für Fachinformatiker für Systemintegration sind Regex wichtig, etwa für die Analyse von Systemlogs oder die Konfiguration von Filterfunktionen.

Nützliche Tools

• regex101.com - Interaktiver Regex-Tester mit Erklärungen
• RegExr - Visueller Regex-Editor mit Bibliothek
• Debuggex - Visualisiert Regex als Zustandsdiagramm

Quellen und weiterführende Links

• Regular-Expressions.info - Umfassende Regex-Referenz
• Python re Dokumentation - Offizielle Python-Regex-Docs
• MDN Regular Expressions - JavaScript Regex Guide
• RexEgg - Fortgeschrittene Regex-Techniken