Regex für Validierung: E-Mail, IP, PLZ, Datum

Eine der häufigsten Aufgaben für Regex in der Praxis: Eingaben validieren. Bevor du eine E-Mail-Adresse in die Datenbank speicherst, möchtest du sichergehen dass sie wenigstens ein @ enthält. Bevor du eine PLZ akzeptierst, soll sie genau 5 Ziffern haben. Bevor eine IP-Adresse durchgereicht wird, soll sie syntaktisch korrekt sein.

Diese Lektion sammelt bewährte Regex-Patterns für die häufigsten Validierungs-Aufgaben. Jedes Pattern hat einen interaktiven Tester – du tippst eine Eingabe ein und siehst sofort grün/rot ob's passt. Die Patterns kannst du direkt in deinen Python- oder JavaScript-Code übernehmen.

1) Validierung vs. Suche – ein wichtiger Unterschied

Beim Validieren willst du nicht „irgendwo finden", sondern „die ganze Eingabe muss matchen". Der Unterschied liegt in den Ankern:

Ohne Anker: \d{5} matched „12345" – aber auch „abc12345xyz" oder „1234567890"
Mit Ankern: ^\d{5}$ matched nur exakt 5-stellige Ziffernfolgen, nichts drumherum

Für Validierung also immer mit ^ und $. Alternative in Python: re.fullmatch() – setzt die Anker automatisch. In JavaScript nutzt das HTML5-pattern-Attribut implizit ^...$.

2) Interaktiver Validator-Builder

Hier kannst du alle wichtigen Validierungs-Patterns ausprobieren. Wechsle die Tabs zwischen E-Mail, PLZ, IP, Datum, IBAN, Telefon. Jeder Validator zeigt das Pattern und prüft deine Eingabe live:

Validator-Lab: live testen

Die Beispiele unten jedes Eingabefelds zeigen Werte, die gültig (grün) oder ungültig (rot) sein sollten. Klick sie an um zu sehen wie der Validator reagiert. Echte Validatoren in Produktion kombinieren Regex oft mit zusätzlichen Checks – z.B. eine Plausibilitäts-Prüfung beim Datum (gibt's den 31. Februar?). Regex prüft Form, nicht Inhalt.

3) E-Mail – ein viel diskutiertes Thema

E-Mail-Validierung ist überraschend komplex. Das obige Pattern ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ deckt 99% der Fälle ab – aber nicht alle. Die echte RFC-5322-Konformität würde ein Pattern brauchen das mehrere Tausend Zeichen lang ist.

Praxis-Empfehlung: pragmatisches Pattern + Versand-Bestätigung. Du validierst grob (hat ein @, hat einen Punkt nach dem @), und prüfst die Realität indem du eine Bestätigungs-Mail schickst. Das ist robuster als jede Regex.

⚠ E-Mail-Regex aus Stack Overflow vermeiden

Du findest online E-Mail-Patterns die alle möglichen Edge-Cases abdecken – und dabei 200 Zeichen lang sind. Tu's nicht. Diese Patterns sind fehleranfällig, schwer zu warten, und bringen kaum Mehrwert gegenüber dem einfachen Pattern oben. Best Practice: einfache Form-Validierung + echter Versand zur Bestätigung. Mehr zu E-Mail-Sicherheit in K11 Secure Coding.

4) IPv4 vs. IPv6

Die IPv4-Validierung mit Range-Check ist schon umfangreich – jedes Oktett muss 0-255 sein. Naiv: ^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$ akzeptiert auch 300.0.0.1. Korrekt mit Range:

IPv4 mit Range 0-255

1^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$

Das Sub-Pattern 25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]? matched 0-255: entweder 250-255, oder 200-249, oder 0-199 (mit optionaler führender 0/1).

IPv6 ist deutlich komplizierter. Die volle Validierung müsste alle Schreibweisen abdecken: 2001:0db8:85a3:0000:0000:8a2e:0370:7334, kompakt 2001:db8:85a3::8a2e:370:7334, oder mit IPv4-Anteil. In der Praxis nutzt man Library-Funktionen statt selbst-gebauter Regex:

Python: IPv4/IPv6 prüfen

1import ipaddress
2try:
3    ipaddress.ip_address(user_input)
4    print("Gültig")
5except ValueError:
6    print("Ungültig")

Mehr zu IP-Adressen in K17 IP-Adressierung.

5) Datum mit echter Plausibilität

Das Datums-Pattern oben prüft nur das Format: gültige Tag- und Monatsbereiche, aber nicht die Kombinations-Plausibilität. 31.02.2026 würde durchgehen – obwohl es den 31. Februar nicht gibt.

Eine Regex die das vollständig löst wäre extrem komplex (Schaltjahre, 30/31-Tage-Monate). Sinnvoller: Regex für Format + Programmcode für Plausibilität:

Python: Datum vollständig validieren

1from datetime import datetime
2import re
3
4def validate_date(s):
5    # 1. Form prüfen
6    if not re.fullmatch(r"\d{2}\.\d{2}\.\d{4}", s):
7        return False
8    # 2. Echte Plausibilität
9    try:
10        datetime.strptime(s, "%d.%m.%Y")
11        return True
12    except ValueError:
13        return False

Das ist die Grundlehre: Regex prüft Form, Programmcode prüft Inhalt. Wer beides will, kombiniert.

6) Passwörter: Multiple Bedingungen mit Lookaheads

Das Passwort-Pattern ist interessant weil es mehrere unabhängige Bedingungen prüft: muss Großbuchstabe haben, muss Kleinbuchstabe haben, muss Ziffer haben, muss Sonderzeichen haben. Dafür nutzt man die Lookahead-Technik aus L3:

Passwort-Pattern dekonstruiert

1^                       # Anfang
2(?=.*[a-z])             # Lookahead: irgendwo Kleinbuchstabe
3(?=.*[A-Z])             # Lookahead: irgendwo Großbuchstabe
4(?=.*[0-9])             # Lookahead: irgendwo Ziffer
5(?=.*[!@#$%^&*])        # Lookahead: irgendwo Sonderzeichen
6[a-zA-Z0-9!@#$%^&*]{8,} # Erlaubte Zeichen, min. 8
7$                       # Ende

Die Lookaheads (?=...) verbrauchen keine Zeichen – sie checken nur ob die Bedingung irgendwo erfüllt ist. Dadurch kannst du mehrere unabhängige Bedingungen kombinieren.

Sicherheits-Anmerkung: starre Passwort-Regeln sind heutzutage nicht mehr Best Practice. NIST empfiehlt Länge wichtiger als Komplexität – ein 16-stelliges Passwort mit nur Buchstaben ist sicherer als ein 8-stelliges mit allen Klassen. Mehr in K07 IT-Sicherheit.

7) Weitere häufige Patterns

Sammlung weiterer Patterns die du oft brauchen wirst:

Validierung	Pattern
ISO-Datum (YYYY-MM-DD)	`^\d{4}-\d{2}-\d{2}$`
ISO-Datum + Zeit	`^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$`
Uhrzeit (HH:MM)	`^([01]\d\|2[0-3]):[0-5]\d$`
UUID v4	`^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$`
Slug (URL-freundlich)	`^[a-z0-9]+(-[a-z0-9]+)*$`
Hex-Ziffer	`^[0-9a-fA-F]+$`
Binär	`^[01]+$`
Positive Zahl	`^[1-9]\d*$`
Dezimalzahl	`^-?\d+(\.\d+)?$`
MAC-Adresse	`^([0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}$`
Kreditkarte (16-stellig)	`^\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}$`
Semantic Version	`^\d+\.\d+\.\d+(-[a-zA-Z0-9.]+)?$`

Wichtig: das sind Format-Validierungen. Echte Validierung enthält oft mehr – z.B. eine Kreditkarte braucht zusätzlich den Luhn-Algorithmus für die Prüfziffer. UUID v4 hat strukturelle Vorgaben (das „4" in der dritten Gruppe ist die Version-Indikation).

8) Frontend + Backend = doppelte Validierung

Wichtige Regel: validiere immer auf beiden Seiten. Frontend (HTML5 + JavaScript) für sofortiges Feedback an den User, Backend für echte Sicherheit:

Frontend nur: User mit DevTools kann jeden Check umgehen – nicht sicher
Backend nur: User sieht Fehler erst nach dem Absenden – schlechte UX
Beide: ideal. Frontend für UX, Backend für Sicherheit

HTML5 + JS Frontend

1<input type="email" required
2       pattern="[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"
3       title="Gültige E-Mail-Adresse">

Browser akzeptiert das Formular nicht ohne match. Aber: ein Angreifer kann mit DevTools das Pattern entfernen oder POST direkt schicken. Daher Backend auch validieren.

9) Validierung ist nicht Sanitierung

Zwei verschiedene Konzepte die oft verwechselt werden:

Validierung: prüfen ob die Eingabe formal korrekt ist (ja/nein)
Sanitierung: gefährliche Teile entfernen oder neutralisieren

Beispiel: eine User-Kommentar-Eingabe sollte:

Validiert werden (max. 5000 Zeichen, kein Newline-Spam, etc.)
Sanitisiert werden vor Anzeige (HTML-Tags escapen gegen XSS)

Regex eignet sich für Format-Validierung. Für Sicherheits-Sanitierung von HTML/SQL gibt's spezielle Libraries – nicht selbst stricken! Mehr in K11 Secure Coding.

10) Praxis: Form-Validator in Python

Beispiel wie eine komplette Validierung in Python aussieht:

user_validation.py

1import re
2
3class Validator:
4    PATTERNS = {
5        "email":    re.compile(r"^[\w.+-]+@[\w.-]+\.\w{2,}$"),
6        "plz":      re.compile(r"^\d{5}$"),
7        "username": re.compile(r"^[a-zA-Z]\w{2,15}$"),
8    }
9
10    def validate(self, field, value):
11        pattern = self.PATTERNS.get(field)
12        if not pattern:
13            raise ValueError(f"Unknown field: {field}")
14        return bool(pattern.fullmatch(value))
15
16# Verwendung:
17v = Validator()
18v.validate("email", "anna@firma.de")   # True
19v.validate("plz", "78462")             # True

Strukturiert mit pre-compiled Patterns – schnell, lesbar, wartbar. In Production-Code würdest du das in Flask oder Spring Boot mit Annotation-basierten Validatoren machen – @Pattern(regexp="..."). Aber das Konzept bleibt: Regex prüft Form.

Zusammenfassung

Validierung mit Regex: immer Anker ^...$ oder fullmatch – ganze Eingabe muss matchen. Bewährte Patterns für E-Mail (pragmatisch, nicht RFC-strict), PLZ ^\d{5}$, IPv4 mit Range-Check, Datum (Format + Plausibilität extra), IBAN, Telefon, Username, Passwort (Lookaheads für mehrere Bedingungen). Pragmatische Grenzen: E-Mail-Regex bleibt pragmatisch + Versand-Bestätigung, IPv6 lieber Library nutzen. Doppelte Validierung: Frontend (UX) + Backend (Sicherheit). Regex prüft Form, nicht Inhalt – für Sicherheits-Sanitierung gegen XSS/SQL-Injection braucht es spezielle Libraries.