Wie kann ich eine E-Mail-Adresse mithilfe eines regulären Ausdrucks überprüfen?

Question

Im Laufe der Jahre habe ich langsam eine regulärer Ausdruck die die Gültigkeit Die meisten E-Mail-Adressen korrekt, vorausgesetzt, sie verwenden keine IP-Adresse als Serverteil.

Ich verwende es in mehreren PHP-Programmen, und es funktioniert die meiste Zeit. Von Zeit zu Zeit werde ich jedoch von jemandem kontaktiert, der Probleme mit einer Website hat, die es verwendet, und ich muss dann einige Anpassungen vornehmen (vor kurzem habe ich festgestellt, dass ich keine vierstelligen Buchstaben zulasse TLDs ).

Was ist der beste reguläre Ausdruck, den Sie haben oder gesehen haben, um E-Mails zu validieren?

Ich habe mehrere Lösungen gesehen, die Funktionen verwenden, die mehrere kürzere Ausdrücke verwenden, aber ich hätte lieber einen langen komplexen Ausdruck in einer einfachen Funktion als mehrere kurze Ausdrücke in einer komplexeren Funktion.

Answer 1

Die vollständig RFC 822-konforme Regex ist aufgrund seiner Länge ineffizient und undurchsichtig. Glücklicherweise wurde RFC 822 zweimal überholt und die aktuelle Spezifikation für E-Mail-Adressen lautet RFC 5322 . RFC 5322 führt zu einer Regex, die man versteht, wenn man sie ein paar Minuten lang studiert, und die effizient genug für die tatsächliche Verwendung ist.

Eine RFC 5322-konforme Regex finden Sie oben auf der Seite unter http://emailregex.com/ sondern verwendet das IP-Adressmuster, das im Internet kursiert und einen Fehler enthält, der es ermöglicht 00 für einen der vorzeichenlosen Byte-Dezimalwerte in einer durch einen Punkt getrennten Adresse, was illegal ist. Der Rest scheint mit der Grammatik von RFC 5322 übereinzustimmen und besteht mehrere Tests mit grep -Po einschließlich Fällen von Domänennamen, IP-Adressen, falschen Adressen und Kontonamen mit und ohne Anführungszeichen.

Berichtigung der 00 Fehler im IP-Muster, erhalten wir eine funktionierende und ziemlich schnelle Regex. (Scrapen Sie die gerenderte Version, nicht den Markdown, für den tatsächlichen Code).

(?:[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])?|\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])) \. ){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-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 ])+)\])

oder:

(?:[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])?|\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-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])+)\])

Hier ist Diagramm%40(%3F%3A(%3F%3A%5Ba-z0-9%5D(%3F%3A%5Ba-z0-9-%5D%5Ba-z0-9%5D)%3F%5C.)%2B%5Ba-z0-9%5D(%3F%3A%5Ba-z0-9-%5D%5Ba-z0-9%5D)%3F%7C%5C%5B(%3F%3A(%3F%3A(2(5%5B0-5%5D%7C%5B0-4%5D%5B0-9%5D)%7C1%5B0-9%5D%5B0-9%5D%7C%5B1-9%5D%3F%5B0-9%5D))%5C.)%7B3%7D(%3F%3A(2(5%5B0-5%5D%7C%5B0-4%5D%5B0-9%5D)%7C1%5B0-9%5D%5B0-9%5D%7C%5B1-9%5D%3F%5B0-9%5D)%7C%5Ba-z0-9-%5D*%5Ba-z0-9%5D%3A(%3F%3A%5B%5Cx01-%5Cx08%5Cx0b%5Cx0c%5Cx0e-%5Cx1f%5Cx21-%5Cx5a%5Cx53-%5Cx7f%5D%7C%5C%5C%5B%5Cx01-%5Cx09%5Cx0b%5Cx0c%5Cx0e-%5Cx7f%5D)%2B)%5C%5D)) de endlicher Automat für obige Regexp, die eindeutiger ist als die Regexp selbst

Die ausgefeilteren Muster in Perl und PCRE (Regex-Bibliothek, die z. B. in PHP verwendet wird) können RFC 5322 korrekt und problemlos parsen . Python und C# können das auch, aber sie verwenden eine andere Syntax als die ersten beiden. Wenn Sie jedoch gezwungen sind, eine der vielen weniger leistungsfähigen Pattern-Matching-Sprachen zu verwenden, dann ist es am besten, einen echten Parser zu benutzen.

Es ist auch wichtig zu verstehen, dass die Validierung nach dem RFC absolut nichts darüber aussagt, ob die Adresse unter der angegebenen Domäne tatsächlich existiert oder ob die Person, die die Adresse eingibt, ihr wahrer Besitzer ist. Immer wieder tragen sich Leute auf diese Weise in Mailinglisten ein. Um dies zu beheben, ist eine ausgefeiltere Art der Validierung erforderlich, bei der der Adresse eine Nachricht mit einem Bestätigungs-Token gesendet wird, das auf derselben Webseite wie die Adresse eingegeben werden soll.

Nur so können Sie sicher sein, dass Sie die Adresse der Person erhalten haben, die sie eingegeben hat. Aus diesem Grund verwenden die meisten Mailinglisten diesen Mechanismus, um Anmeldungen zu bestätigen. Schließlich kann sich jeder eintragen. president@whitehouse.gov und das wird sogar als legal angesehen, aber es ist unwahrscheinlich, dass es die Person am anderen Ende ist.

Für PHP sollten Sie no verwenden Sie das Muster, das in E-Mail-Adressen mit PHP validieren, der richtige Weg aus dem ich zitiere:

Es besteht die Gefahr, dass sich durch den allgemeinen Gebrauch und die weit verbreitete schlampige Kodierung ein De-facto-Standard für E-Mail-Adressen etabliert, der restriktiver ist als der aufgezeichnete formale Standard.

Das ist nicht besser als alle anderen Nicht-RFC-Muster. Es ist nicht einmal klug genug, um selbst mit RFC 822 geschweige denn RFC 5322. Diese jedoch ist.

Wenn Sie es ganz genau wissen wollen, eine vollständige State-Engine zu implementieren . Ein regulärer Ausdruck kann nur als rudimentärer Filter dienen. Das Problem mit regulären Ausdrücken besteht darin, dass es aus Sicht des Benutzers unhöflich ist, jemandem mitzuteilen, dass seine vollkommen gültige E-Mail-Adresse ungültig ist (ein falsches Positiv), weil der reguläre Ausdruck sie nicht verarbeiten kann. Eine State-Engine für diesen Zweck kann E-Mail-Adressen, die ansonsten als ungültig gelten würden, sowohl validieren als auch korrigieren, da sie die E-Mail-Adresse gemäß den einzelnen RFCs zerlegt. Dies ermöglicht eine potentiell angenehmere Erfahrung, wie

Die angegebene E-Mail-Adresse 'myemail@address,com' ist ungültig. Meinten Sie 'myemail@address.com'?

Siehe auch Überprüfen von E-Mail-Adressen , einschließlich der Kommentare. Oder Vergleichen von regulären Ausdrücken zur Überprüfung von E-Mail-Adressen .

Debuggex-Demo

Answer 2

Sie sollten keine regulären Ausdrücke zur Überprüfung von E-Mail-Adressen verwenden.

Verwenden Sie stattdessen in C# die MailAdresse Klasse, etwa so:

try {
    address = new MailAddress(address).Address;
} catch(FormatException) {
    // address is invalid
}

Die MailAddress Klasse verwendet eine BNF Parser, um die Adresse in voller Übereinstimmung mit RFC822 zu validieren.

Wenn Sie planen, die MailAddress um die E-Mail-Adresse zu validieren, sollten Sie beachten, dass dieser Ansatz auch den Teil des Anzeigenamens der E-Mail-Adresse akzeptiert, und das ist vielleicht nicht genau das, was Sie erreichen wollen. Zum Beispiel werden diese Zeichenfolgen als gültige E-Mail-Adressen akzeptiert:

• "user1@hotmail.com; user2@gmail.com"
• "user1@hotmail.com; user2@gmail.com; user3@company.com"
• "Benutzer-Anzeigename user3@company.com"
• "user4 @firma.de"

In einigen dieser Fälle wird nur der letzte Teil der Zeichenkette als Adresse geparst; der Rest davor ist der Anzeigename. Um eine einfache E-Mail-Adresse ohne Anzeigenamen zu erhalten, können Sie die normalisierte Adresse mit Ihrer ursprünglichen Zeichenfolge vergleichen.

bool isValid = false;

try
{
    MailAddress address = new MailAddress(emailAddress);
    isValid = (address.Address == emailAddress);
    // or
    // isValid = string.IsNullOrEmpty(address.DisplayName);
}
catch (FormatException)
{
    // address is invalid
}

Außerdem kann eine Adresse mit einem Punkt am Ende, wie user@company. wird auch von MailAddress akzeptiert.

Wenn Sie wirklich eine Regex verwenden wollen, hier ist es :

(?:(?:\\r\\n)?\[ \\t\])\*(?:(?:(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\]
)+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|"(?:\[^\\"\\r\\\\\]|\\\\.|(?:(?:\\r\\n)?\[ \\t\]))\*"(?:(?:
\\r\\n)?\[ \\t\])\*)(?:\\.(?:(?:\\r\\n)?\[ \\t\])\*(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(
?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|"(?:\[^\\"\\r\\\\\]|\\\\.|(?:(?:\\r\\n)?\[ 
\\t\]))\*"(?:(?:\\r\\n)?\[ \\t\])\*))\*@(?:(?:\\r\\n)?\[ \\t\])\*(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\0
31\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|\\\[(\[^\\\[\\\]\\r\\\\\]|\\\\.)\*\\
\](?:(?:\\r\\n)?\[ \\t\])\*)(?:\\.(?:(?:\\r\\n)?\[ \\t\])\*(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+
(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|\\\[(\[^\\\[\\\]\\r\\\\\]|\\\\.)\*\\\](?:
(?:\\r\\n)?\[ \\t\])\*))\*|(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z
|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|"(?:\[^\\"\\r\\\\\]|\\\\.|(?:(?:\\r\\n)?\[ \\t\]))\*"(?:(?:\\r\\n)
?\[ \\t\])\*)\*\\<(?:(?:\\r\\n)?\[ \\t\])\*(?:@(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\
r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|\\\[(\[^\\\[\\\]\\r\\\\\]|\\\\.)\*\\\](?:(?:\\r\\n)?\[
 \\t\])\*)(?:\\.(?:(?:\\r\\n)?\[ \\t\])\*(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)
?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|\\\[(\[^\\\[\\\]\\r\\\\\]|\\\\.)\*\\\](?:(?:\\r\\n)?\[ \\t\]
)\*))\*(?:,@(?:(?:\\r\\n)?\[ \\t\])\*(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[
 \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|\\\[(\[^\\\[\\\]\\r\\\\\]|\\\\.)\*\\\](?:(?:\\r\\n)?\[ \\t\])\*
)(?:\\.(?:(?:\\r\\n)?\[ \\t\])\*(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\]
)+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|\\\[(\[^\\\[\\\]\\r\\\\\]|\\\\.)\*\\\](?:(?:\\r\\n)?\[ \\t\])\*))\*)
\*:(?:(?:\\r\\n)?\[ \\t\])\*)?(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+
|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|"(?:\[^\\"\\r\\\\\]|\\\\.|(?:(?:\\r\\n)?\[ \\t\]))\*"(?:(?:\\r
\\n)?\[ \\t\])\*)(?:\\.(?:(?:\\r\\n)?\[ \\t\])\*(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:
\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|"(?:\[^\\"\\r\\\\\]|\\\\.|(?:(?:\\r\\n)?\[ \\t
\]))\*"(?:(?:\\r\\n)?\[ \\t\])\*))\*@(?:(?:\\r\\n)?\[ \\t\])\*(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031
\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|\\\[(\[^\\\[\\\]\\r\\\\\]|\\\\.)\*\\\](
?:(?:\\r\\n)?\[ \\t\])\*)(?:\\.(?:(?:\\r\\n)?\[ \\t\])\*(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?
:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|\\\[(\[^\\\[\\\]\\r\\\\\]|\\\\.)\*\\\](?:(?
:\\r\\n)?\[ \\t\])\*))\*\\>(?:(?:\\r\\n)?\[ \\t\])\*)|(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?
:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|"(?:\[^\\"\\r\\\\\]|\\\\.|(?:(?:\\r\\n)?
\[ \\t\]))\*"(?:(?:\\r\\n)?\[ \\t\])\*)\*:(?:(?:\\r\\n)?\[ \\t\])\*(?:(?:(?:\[^()<>@,;:\\\\".\\\[\\\] 
\\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|"(?:\[^\\"\\r\\\\\]|
\\\\.|(?:(?:\\r\\n)?\[ \\t\]))\*"(?:(?:\\r\\n)?\[ \\t\])\*)(?:\\.(?:(?:\\r\\n)?\[ \\t\])\*(?:\[^()<>

@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|"
(?:\[^\\"\\r\\\\\]|\\\\.|(?:(?:\\r\\n)?\[ \\t\]))\*"(?:(?:\\r\\n)?\[ \\t\])\*))\*@(?:(?:\\r\\n)?\[ \\t\]
)\*(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\
".\\\[\\\]\]))|\\\[(\[^\\\[\\\]\\r\\\\\]|\\\\.)\*\\\](?:(?:\\r\\n)?\[ \\t\])\*)(?:\\.(?:(?:\\r\\n)?\[ \\t\])\*(?
:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[
\\\]\]))|\\\[(\[^\\\[\\\]\\r\\\\\]|\\\\.)\*\\\](?:(?:\\r\\n)?\[ \\t\])\*))\*|(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-
\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|"(?:\[^\\"\\r\\\\\]|\\\\.|(
?:(?:\\r\\n)?\[ \\t\]))\*"(?:(?:\\r\\n)?\[ \\t\])\*)\*\\<(?:(?:\\r\\n)?\[ \\t\])\*(?:@(?:\[^()<>@,;
:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|\\\[(\[
^\\\[\\\]\\r\\\\\]|\\\\.)\*\\\](?:(?:\\r\\n)?\[ \\t\])\*)(?:\\.(?:(?:\\r\\n)?\[ \\t\])\*(?:\[^()<>@,;:\\\\"
.\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|\\\[(\[^\\\[\\
\]\\r\\\\\]|\\\\.)\*\\\](?:(?:\\r\\n)?\[ \\t\])\*))\*(?:,@(?:(?:\\r\\n)?\[ \\t\])\*(?:\[^()<>@,;:\\\\".\\
\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|\\\[(\[^\\\[\\\]\\
r\\\\\]|\\\\.)\*\\\](?:(?:\\r\\n)?\[ \\t\])\*)(?:\\.(?:(?:\\r\\n)?\[ \\t\])\*(?:\[^()<>@,;:\\\\".\\\[\\\] 
\\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|\\\[(\[^\\\[\\\]\\r\\\\\]
|\\\\.)\*\\\](?:(?:\\r\\n)?\[ \\t\])\*))\*)\*:(?:(?:\\r\\n)?\[ \\t\])\*)?(?:\[^()<>@,;:\\\\".\\\[\\\] \\0
00-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|"(?:\[^\\"\\r\\\\\]|\\\\
.|(?:(?:\\r\\n)?\[ \\t\]))\*"(?:(?:\\r\\n)?\[ \\t\])\*)(?:\\.(?:(?:\\r\\n)?\[ \\t\])\*(?:\[^()<>@,
;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|"(?
:\[^\\"\\r\\\\\]|\\\\.|(?:(?:\\r\\n)?\[ \\t\]))\*"(?:(?:\\r\\n)?\[ \\t\])\*))\*@(?:(?:\\r\\n)?\[ \\t\])\*
(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\".
\\\[\\\]\]))|\\\[(\[^\\\[\\\]\\r\\\\\]|\\\\.)\*\\\](?:(?:\\r\\n)?\[ \\t\])\*)(?:\\.(?:(?:\\r\\n)?\[ \\t\])\*(?:\[
^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]
\]))|\\\[(\[^\\\[\\\]\\r\\\\\]|\\\\.)\*\\\](?:(?:\\r\\n)?\[ \\t\])\*))\*\\>(?:(?:\\r\\n)?\[ \\t\])\*)(?:,\\s\*(
?:(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\
".\\\[\\\]\]))|"(?:\[^\\"\\r\\\\\]|\\\\.|(?:(?:\\r\\n)?\[ \\t\]))\*"(?:(?:\\r\\n)?\[ \\t\])\*)(?:\\.(?:(
?:\\r\\n)?\[ \\t\])\*(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[
\\\["()<>@,;:\\\\".\\\[\\\]\]))|"(?:\[^\\"\\r\\\\\]|\\\\.|(?:(?:\\r\\n)?\[ \\t\]))\*"(?:(?:\\r\\n)?\[ \\t
\])\*))\*@(?:(?:\\r\\n)?\[ \\t\])\*(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t
\])+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|\\\[(\[^\\\[\\\]\\r\\\\\]|\\\\.)\*\\\](?:(?:\\r\\n)?\[ \\t\])\*)(?
:\\.(?:(?:\\r\\n)?\[ \\t\])\*(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|
\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|\\\[(\[^\\\[\\\]\\r\\\\\]|\\\\.)\*\\\](?:(?:\\r\\n)?\[ \\t\])\*))\*|(?:
\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\
\]\]))|"(?:\[^\\"\\r\\\\\]|\\\\.|(?:(?:\\r\\n)?\[ \\t\]))\*"(?:(?:\\r\\n)?\[ \\t\])\*)\*\\<(?:(?:\\r\\n)
?\[ \\t\])\*(?:@(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["
()<>@,;:\\\\".\\\[\\\]\]))|\\\[(\[^\\\[\\\]\\r\\\\\]|\\\\.)\*\\\](?:(?:\\r\\n)?\[ \\t\])\*)(?:\\.(?:(?:\\r\\n)
?\[ \\t\])\*(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>

@,;:\\\\".\\\[\\\]\]))|\\\[(\[^\\\[\\\]\\r\\\\\]|\\\\.)\*\\\](?:(?:\\r\\n)?\[ \\t\])\*))\*(?:,@(?:(?:\\r\\n)?\[
 \\t\])\*(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,
;:\\\\".\\\[\\\]\]))|\\\[(\[^\\\[\\\]\\r\\\\\]|\\\\.)\*\\\](?:(?:\\r\\n)?\[ \\t\])\*)(?:\\.(?:(?:\\r\\n)?\[ \\t\]
)\*(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\
".\\\[\\\]\]))|\\\[(\[^\\\[\\\]\\r\\\\\]|\\\\.)\*\\\](?:(?:\\r\\n)?\[ \\t\])\*))\*)\*:(?:(?:\\r\\n)?\[ \\t\])\*)?
(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\["()<>@,;:\\\\".
\\\[\\\]\]))|"(?:\[^\\"\\r\\\\\]|\\\\.|(?:(?:\\r\\n)?\[ \\t\]))\*"(?:(?:\\r\\n)?\[ \\t\])\*)(?:\\.(?:(?:
\\r\\n)?\[ \\t\])\*(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z|(?=\[\\\[
"()<>@,;:\\\\".\\\[\\\]\]))|"(?:\[^\\"\\r\\\\\]|\\\\.|(?:(?:\\r\\n)?\[ \\t\]))\*"(?:(?:\\r\\n)?\[ \\t\])
\*))\*@(?:(?:\\r\\n)?\[ \\t\])\*(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])
+|\\Z|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|\\\[(\[^\\\[\\\]\\r\\\\\]|\\\\.)\*\\\](?:(?:\\r\\n)?\[ \\t\])\*)(?:\\
.(?:(?:\\r\\n)?\[ \\t\])\*(?:\[^()<>@,;:\\\\".\\\[\\\] \\000-\\031\]+(?:(?:(?:\\r\\n)?\[ \\t\])+|\\Z
|(?=\[\\\["()<>@,;:\\\\".\\\[\\\]\]))|\\\[(\[^\\\[\\\]\\r\\\\\]|\\\\.)\*\\\](?:(?:\\r\\n)?\[ \\t\])\*))\*\\>(?:(
?:\\r\\n)?\[ \\t\])\*))\*)?;\\s\*)

Answer 3

Diese Frage wird oft gestellt, aber ich denke, Sie sollten einen Schritt zurücktreten und sich fragen warum Sie möchten E-Mail-Adressen syntaktisch validieren? Was ist der eigentliche Nutzen?

• Übliche Tippfehler werden nicht erkannt.
• Sie verhindert nicht, dass Personen ungültige oder erfundene E-Mail-Adressen oder die Adresse einer anderen Person eingeben.

Wenn Sie überprüfen wollen, ob eine E-Mail korrekt ist, haben Sie keine andere Wahl, als eine Bestätigungs-E-Mail zu senden und den Benutzer darauf antworten zu lassen. In vielen Fällen werden Sie haben aus Sicherheitsgründen oder aus ethischen Gründen (damit Sie z. B. niemanden gegen seinen Willen für einen Dienst anmelden können) trotzdem eine Bestätigungsmail schicken.

Answer 4

Es hängt alles davon ab, wie genau Sie sein wollen. Für meine Zwecke, bei denen ich nur versuche, Dinge herauszuhalten wie bob @ aol.com (Leerzeichen in E-Mails) oder steve (überhaupt keine Domäne) oder mary@aolcom (kein Punkt vor .com), verwende ich

/^\S+@\S+\.\S+$/

Natürlich werden auch ungültige E-Mail-Adressen abgeglichen, aber es geht darum, einfache Fehler zu erkennen.

Es gibt eine Reihe von Änderungen, die an dieser Regex vorgenommen werden können (und einige sind in den Kommentaren zu dieser Antwort), aber sie ist einfach und leicht zu verstehen und ist ein guter erster Versuch.

Answer 5

Das hängt davon ab, was Sie mit "am besten" meinen: Wenn es darum geht, alle gültigen E-Mail-Adressen zu erfassen, verwenden Sie Folgendes:

(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:
\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(
?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ 
\t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\0
31]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\
](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+
(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:
(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)
?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\
r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[
 \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)
?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t]
)*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[
 \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*
)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)
*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+
|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r
\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:
\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t
]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031
]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](
?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?
:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?
:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?
:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?
[ \t]))*"(?:(?:\r\n)?[ \t])*)*:(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] 
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|
\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>
@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"
(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?
:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[
\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-
\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(
?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;
:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([
^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"
.\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\
]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\
[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\
r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] 
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]
|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \0
00-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\
.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,
;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?
:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[
^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]
]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)(?:,\s*(
?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(
?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[
\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t
])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t
])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?
:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|
\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:
[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\
]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)
?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["
()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)
?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>
@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[
 \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,
;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:
\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[
"()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])
*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])
+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\
.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(
?:\r\n)?[ \t])*))*)?;\s*)

( http://www.ex-parrot.com/~pdw/Mail-RFC822-Adressen.html ) Wenn Sie etwas Einfacheres suchen, das aber die meisten gültigen E-Mail-Adressen erfasst, probieren Sie etwas wie:

"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"

EDIT: Aus dem Link:

Dieser reguläre Ausdruck prüft nur Adressen, bei denen alle Kommentare entfernt und durch Leerzeichen ersetzt wurden (dies geschieht durch das Modul).