Was für einen global akzeptierten regulärer Ausdruck wäre E-Mail-Adressen entsprechen
https://stackoverflow.com/questions/210945
-
03-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Ich habe viele Beispiele gesehen, mit vielen Kommentaren ‚nein, du etwas verpasst‘. Was ist der richtige Weg, um eine E-Mail-Adresse übereinstimmen?
Für Sanity willen, nur vollqualifizierten Domain-Name, keine @localhost erlaubt. (Oder beiden Richtungen)
Subdomains muss erlaubt sein (issac@deptartment.company.museum)
Andere Tipps
Es ist unmöglich, dies in einer reinen Regex zu tun. Regexen können verschachtelte Klammern nicht überein, die die volle RFC-Spezifikation erfordert. (Die neueste RFC zu diesem Thema ist RFC5322, erst vor wenigen Monaten veröffentlicht.)
Vollständige Validierung von E-Mail-Adressen erfordert etwas entlang der Linien eines CFG, und es gibt ein paar Dinge, vorsichtig zu sein; zum Beispiel E-Mail-Adressen können '\0', die Nullzeichen enthalten ... so kann man nicht alle C normalen String-Funktionen auf sie verwenden.
Ich fühle mich tatsächlich ein bisschen komisch eine Frage mit einem Link zu etwas Beantwortung ich geschrieben habe, aber da es so passiert, ich habe, den ich früher vorbereitet: ein kurze und (soweit ich das beurteilen kann) vollständig konformer Validator , in Haskell; Sie können href="http://hackage.haskell.org/packages/archive/email-validate/0.2/doc/html/src/Text-Email-Validate.html" sehen Code hier . Ich stelle mir den Code leicht an jede ähnliche Parsing-Bibliothek portiert werden könnte (vielleicht C ++ 's Boost.Spirit) oder ebenso leicht angespannt in einer anderen Sprache (Haskell hat eine sehr einfache Art und Weise für C Haskell Code zu verwenden, und alles kann C-Bindungen verwenden ...)
Es gibt auch umfangreiche Testfälle im Quellcode (ich habe sie nicht aus dem Modul Export), die fällig sind Dominic Sayers , der in PHP seine eigene Version eines RFC-konformen Parser hat. (Einige der Tests fehlschlagen, aber sie sind strenger als RFC5322 spezifiziert, so dass ich mich gut mit, dass im Moment.)
Das wurde gefragt hier ein paar Wochen. Worauf es ankommt, ist, gibt es viele rechtliche Adressen, die eine einfache Regex nicht überein. Es dauert eine wirklich verrückt regex die Mehrheit der Rechts Adressen übereinstimmen. Und selbst dann eine syntaktisch juristische Adresse nicht die Existenz eines Konto dahinter garantiert -. Nehmen foo@example.invalid, zum Beispiel
Ganz zu schweigen davon, dass chinesische / Arabisch Domain-Namen werden in der nahen Zukunft dürfen. Jeder hat den E-Mail-Regex verwendet zu ändern, da diese Zeichen sind sicherlich nicht von [a-z]/i noch \w abgedeckt werden. Sie werden alle scheitern.
Schließlich, am bester Weg, um die E-Mail-Adresse zu bestätigen ist nach wie vor, um tatsächlich eine E-Mail an die Adresse in Frage zu senden, um die Adresse zu bestätigen. Wenn die E-Mail-Adresse ist Teil der Benutzerauthentifizierung (Registrieren / Anmelden / etc), dann können Sie perfekt kombinieren es mit dem Benutzer-Aktivierungssystem. D. h Bitte senden Sie eine E-Mail mit einem Link mit einem einzigartigen Aktivierungsschlüssel an die angegebenen E-Mail-Adresse und nur erlauben Login, wenn der Benutzer das neu erstellte Konto über den Link in der E-Mail aktiviert hat.
Wenn der Zweck der Regex nur ist, um schnell den Benutzer in der Benutzeroberfläche zu informieren, dass die angegebene E-Mail-Adresse sieht nicht aus wie im richtigen Format, am besten noch zu prüfen, ob es im Grunde die folgende regex entspricht:
([^.@]+)(\\.[^.@]+)*@([^.@]+\\.)+([^.@]+)
So einfach ist das. Warum in aller Welt kümmern würde Sie über die Zeichen im Namen und Domain verwendet?
Leider ist es nicht ein regulärer Ausdruck, aber ... Der richtige Weg, um eine E-Mail-Adresse zu bestätigen ist ihm eine Nachricht zu senden und sehen, ob die Benutzer Antworten.
Wenn Sie wirklich sicher, wirklich wollen, dass eine Adresse ist syntaktisch gültig / RFC-konform, dann ein regulärer Ausdruck ist immer noch unwahrscheinlich, dass das richtige Werkzeug für den Job sein. Sie könnten am ehesten einen Parser in weniger Zeichen als die Länge eines Regex mit einem ähnlichen Niveau der RFC Compliance erstellen und dem Parser wahrscheinlich schneller zu booten laufen würde.
Auch bei einem umfassenden Test-RFC Compliance wird anon@ymo.us perfekt geformt und bezieht sich auf eine bestehende Domain, so dass Sie nicht wissen, ob die Adresse, die Sie gegeben sind tatsächlich gültig ist oder nicht, wenn Sie Bitte senden sie eine Nachricht.
Es gibt eine weitere Diskussion über diese hier: Mit einem regulären Ausdruck eine E-Mail-Adresse
Allgemeine Hinweise sind nicht
Es ist wahrscheinlich lohnt eine einfache Prüfung, dass sie „something@somethign.something“ eingegeben nur um zu überprüfen sie die E-Mail in der rechten Box.
Darüber hinaus die meisten der offiziellen regex für so viele dunkle Fällen zulassen, dass sie eine riesige falsch-positive Rate haben (sie werden technisch legal ermöglichen, aber äußerst unwahrscheinlich
Einträge)
http://www.ex-parrot.com /~pdw/Mail-RFC822-Address.html :
Die Grammatik in RFC 822 beschrieben ist überraschend komplex. Die Implementierung Validierung mit regulären Ausdrücken drückt etwas die Grenzen dessen, was es ist vernünftig mit regulären Ausdrücken zu tun, obwohl Perl meistert auch:
(?:(?:\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*)
Wenn Sie Perl verwenden, glaube ich, die Regex :: Gemeinsames Modul derjenige sein würde, die Sie verwenden möchten, und insbesondere Regex :: Allgemeine :: Email :: Adresse.
Ich musste vor kurzem einige RSS bauen Feeds und ein Teil davon über das XML-Schema enthalten gehen, einschließlich der Elemente für Webmaster und managingEditor, die beide als eine E-Mail-Adresse definiert sind für diese Muster:
([a-zA-Z0-9_\-])([a-zA-Z0-9_\-\.]*)@(\[((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}|((([a-zA-Z0-9\-]+)\.)+))([a-zA-Z]{2,}|(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\])
