Die komplette E-Mail Regex erklärt

← Zurück zum E-Mail Extractor

Was ist ein regulärer Ausdruck (Regex)?

Ein regulärer Ausdruck (oft als Regex oder Regexp abgekürzt) ist eine Zeichenfolge, die ein Suchmuster definiert. Reguläre Ausdrücke werden in praktisch jeder Programmiersprache und jedem Texteditor verwendet, um Zeichenketten zu finden, abzugleichen und zu manipulieren. Sie sind besonders leistungsstark für Mustererkennungsaufgaben wie die Validierung von Benutzereingaben, das Durchsuchen großer Textmengen oder das Extrahieren bestimmter Daten wie E-Mail-Adressen, Telefonnummern oder URLs.

Im Kern beschreibt ein Regex die Struktur des Textes, den du finden möchtest. Anstatt nach einem bestimmten Wort zu suchen, beschreibst du das Muster der Zeichen. Der Regex \d{3} zum Beispiel findet drei aufeinanderfolgende Ziffern, egal ob es sich um „123“, „456“ oder „789“ handelt.

Bei der E-Mail-Extraktion ist Regex die bevorzugte Methode. Jede E-Mail-Adresse folgt einer vorhersehbaren Struktur: ein lokaler Teil, das @-Zeichen und eine Domain. Dieses vorhersehbare Format macht E-Mail-Adressen zu idealen Kandidaten für den Regex-Abgleich.

Das Standard-E-Mail-Regex-Muster

Das am häufigsten verwendete E-Mail-Regex-Muster lautet:

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

Dieses Muster bietet ein gutes Gleichgewicht zwischen Genauigkeit und Einfachheit. Es erkennt die überwiegende Mehrheit realer E-Mail-Adressen korrekt, ohne unnötig komplex zu sein. Schauen wir uns an, was jeder Teil genau bewirkt.

Aufschlüsselung der einzelnen Teile

1. Der lokale Teil: [a-zA-Z0-9._%+-]+

Dies ist der Abschnitt vor dem @-Zeichen (z.B. „max.mustermann“ in max.mustermann@beispiel.de). Die Zeichenklasse [a-zA-Z0-9._%+-] erkennt:

• a-z – Kleinbuchstaben
• A-Z – Großbuchstaben
• 0-9 – Ziffern
• . – Punkte
• _ – Unterstriche
• % – Prozentzeichen
• + – Pluszeichen
• - – Bindestriche

Der +-Quantifizierer nach der Klammer bedeutet „eines oder mehrere dieser Zeichen“. Der lokale Teil muss also mindestens ein Zeichen aus der erlaubten Menge enthalten.

2. Das At-Zeichen: @

Dies ist eine wörtliche Übereinstimmung für das @-Zeichen. Jede gültige E-Mail-Adresse enthält genau ein @-Zeichen, das den lokalen Teil von der Domain trennt. In Regex hat das @-Zeichen keine besondere Bedeutung und wird daher direkt abgeglichen.

3. Der Domainname: [a-zA-Z0-9.-]+

Dies erkennt den Domain-Abschnitt (z.B. „beispiel“ oder „mail.beispiel“ in user@mail.beispiel.de). Die erlaubten Zeichen sind:

• a-z, A-Z – Buchstaben
• 0-9 – Ziffern
• . – Punkte (für Subdomains wie mail.beispiel)
• - – Bindestriche (häufig in Domainnamen wie meine-firma.de)

4. Der Punkt vor der TLD: \.

Dies erkennt ein wörtliches Punkt-Zeichen. Der Backslash ist notwendig, da ein nicht-escaptes . in Regex jedes beliebige Zeichen erkennt. Das \. stellt sicher, dass nur ein tatsächlicher Punkt abgeglichen wird, der den Domainnamen von der Top-Level-Domain trennt.

5. Die Top-Level-Domain (TLD): [a-zA-Z]{2,}

Dies erkennt die TLD wie „com“, „org“, „net“, „de“ oder neuere TLDs wie „technology“ oder „email“. Der {2,}-Quantifizierer bedeutet „zwei oder mehr Zeichen“, wodurch gültige TLDs erkannt werden (die kürzesten wie „.de“ oder „.at“ haben zwei Zeichen), während auch längere TLDs wie „.museum“ oder „.photography“ abgedeckt werden.

Gängige Regex-Varianten

Einfach und permissiv

Für eine schnelle Prüfung ohne Rücksicht auf Sonderfälle:

.+@.+\..+

Dies erkennt „irgendetwas, dann @, dann irgendetwas, dann ein Punkt, dann irgendetwas“. Es ist schnell, erkennt aber auch viele ungültige Zeichenketten.

Strenges praktisches Muster

Ein strengeres Muster mit vernünftigen Einschränkungen:

^[a-zA-Z0-9](?:[a-zA-Z0-9._%+-]{0,63})@(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,63}$

Diese Version fügt mehrere Verbesserungen hinzu:

• Der lokale Teil muss mit einem alphanumerischen Zeichen beginnen
• Domain-Labels müssen mit alphanumerischen Zeichen beginnen und enden
• Maximale Label-Längen werden durchgesetzt (63 Zeichen gemäß RFC 1035)
• Die TLD ist auf 63 Zeichen begrenzt

RFC 5322-konformes Muster

Der offizielle RFC-5322-Standard definiert die vollständige E-Mail-Syntax. Ein wirklich konformer Regex ist extrem lang und komplex:

(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?: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]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])

In der Praxis verwendet fast niemand den vollständigen RFC-5322-Regex. Das Standardmuster [a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,} deckt 99,9 % der realen E-Mail-Adressen ab und ist wesentlich einfacher zu lesen, zu pflegen und zu debuggen.

Code-Beispiele

JavaScript

Alle E-Mails aus einem String extrahieren

function extractEmails(text) {
  const regex = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
  const matches = text.match(regex);
  return matches ? [...new Set(matches)] : [];
}

// Beispiel
const text = "Kontaktieren Sie uns unter info@beispiel.de oder support@firma.org";
const emails = extractEmails(text);
console.log(emails);
// Ausgabe: ["info@beispiel.de", "support@firma.org"]

Eine einzelne E-Mail-Adresse validieren

function isValidEmail(email) {
  const regex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
  return regex.test(email);
}

console.log(isValidEmail("nutzer@beispiel.de"));  // true
console.log(isValidEmail("ungueltig@.de"));        // false
console.log(isValidEmail("kein-at-zeichen.de"));   // false

Python

E-Mails extrahieren und validieren

import re

def extract_emails(text):
    pattern = r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}'
    return list(set(re.findall(pattern, text)))

def is_valid_email(email):
    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    return bool(re.match(pattern, email))

# E-Mails aus Text extrahieren
text = """
Kontaktieren Sie den Vertrieb unter vertrieb@beispiel.de.
Technischer Support: hilfe@support.beispiel.org
Sie können auch den Geschäftsführer erreichen: gf@grosse-firma.co.uk
"""
emails = extract_emails(text)
print(emails)
# Ausgabe: ['vertrieb@beispiel.de', 'hilfe@support.beispiel.org', 'gf@grosse-firma.co.uk']

# Einzelne E-Mail validieren
print(is_valid_email("test@beispiel.de"))  # True
print(is_valid_email("keine-email"))        # False

PHP

E-Mails aus einem String extrahieren

<?php
function extractEmails(string $text): array {
    $pattern = '/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/';
    preg_match_all($pattern, $text, $matches);
    return array_unique($matches[0]);
}

// Beispiel
$text = "Schreiben Sie uns an kontakt@beispiel.de oder admin@webseite.org.";
$emails = extractEmails($text);
print_r($emails);
// Ausgabe: Array ( [0] => kontakt@beispiel.de [1] => admin@webseite.org )

// Einzelne E-Mail validieren (PHP hat auch eine eingebaute Funktion)
$email = "nutzer@beispiel.de";
if (filter_var($email, FILTER_VALIDATE_EMAIL)) {
    echo "$email ist gültig\n";
}
?>

Häufige Stolperfallen und Sonderfälle

1. Internationalisierte E-Mail-Adressen (IDN)

Der Standard-Regex verarbeitet keine internationalisierten Domainnamen (IDN) oder lokale Teile mit Unicode-Zeichen. E-Mail-Adressen wie user@beispiel.de funktionieren einwandfrei, aber user@bsp.xn--e1afmapc (Punycode) oder Adressen mit Umlauten im lokalen Teil (müller@beispiel.de) werden nicht erkannt. Wenn du diese unterstützen musst, müssen die Zeichenklassen um Unicode-Bereiche erweitert werden.

2. Neue und lange TLDs

Seit der Einführung neuer generischer TLDs (gTLDs) können E-Mail-Adressen mit TLDs wie .photography, .technology oder .international enden. Der {2,}-Quantifizierer in unserem Muster verarbeitet diese korrekt. Ältere Muster mit {2,4} würden bei diesen längeren TLDs jedoch versagen – stell sicher, dass dein Regex {2,} oder mindestens {2,63} verwendet.

3. Zitierte lokale Teile

Die E-Mail-Spezifikation erlaubt technisch zitierte Zeichenketten im lokalen Teil, wie "max mustermann"@beispiel.de. Diese sind gemäß RFC 5322 gültig, kommen in der Praxis aber extrem selten vor. Der Standard-Regex erkennt sie nicht, was für die meisten realen Anwendungsfälle akzeptabel ist.

4. IP-Adressen als Domain

E-Mails können technisch IP-Adressen statt Domainnamen verwenden: user@[192.168.1.1] oder user@[IPv6:2001:db8::1]. Diese sind gültig, werden in der Praxis aber fast nie verwendet. Der Standard-Regex erkennt sie nicht.

5. Aufeinanderfolgende Punkte

Der Standard-Regex erlaubt aufeinanderfolgende Punkte im lokalen Teil (z.B. user..name@beispiel.de), was gemäß RFC 5321 technisch ungültig ist. Wenn du diese ablehnen musst, füge einen negativen Lookahead hinzu: (?!.*\.\.)[a-zA-Z0-9._%+-]+.

6. Abschließende Punkte im extrahierten Text

Beim Extrahieren von E-Mails aus natürlichem Text können Sätze wie „Kontaktieren Sie uns unter info@beispiel.de.“ dazu führen, dass der abschließende Punkt als Teil der E-Mail erfasst wird. Unser Regex behandelt dies korrekt, da \.[a-zA-Z]{2,} mindestens zwei Buchstaben nach dem letzten Punkt erfordert.

Wann Regex vs. eingebaute Validierung verwenden?

Viele Programmiersprachen bieten eingebaute E-Mail-Validierung, die robuster ist als ein benutzerdefinierter Regex:

• PHP: filter_var($email, FILTER_VALIDATE_EMAIL)
• Python: Die email-validator-Bibliothek bietet gründliche Validierung einschließlich DNS-Prüfungen
• JavaScript: HTML5 <input type="email"> bietet browsernative Validierung
• .NET: System.Net.Mail.MailAddress parst und validiert E-Mails

Verwende Regex, wenn du E-Mails aus unstrukturiertem Text extrahieren musst. Verwende eingebaute Validatoren, wenn du eine einzelne E-Mail-Adresse aus einem Formularfeld validieren musst. Für Extraktionsaufgaben ist Regex der klare Gewinner, da eingebaute Validatoren nur eine Adresse gleichzeitig prüfen können und nicht durch Text scannen können.

Performance-Tipps

Bei der Verarbeitung sehr großer Textmengen (Megabytes an Daten) beachte diese Performance-Tipps:

• Regex kompilieren: In Sprachen wie Python verwende re.compile(), um das Muster vorzukompilieren, wenn du es wiederholt verwendest
• Globales Flag verwenden: In JavaScript füge immer das g-Flag hinzu, um alle Treffer zu finden, nicht nur den ersten
• Backtracking vermeiden: Der Standard-E-Mail-Regex ist effizient und verursacht kein katastrophales Backtracking, aber übermäßig komplexe Muster können dies tun
• Ergebnisse deduplizieren: Verwende ein Set (JavaScript) oder set (Python), um doppelte E-Mail-Adressen effizient aus deinen Ergebnissen zu entfernen