Was ist falsch an diesem RegEx für die Validierung von E-Mails?

Question

Hier ist eine Regex für die Validierung von E-Mails - \S+@\S+\.\S+ Ich habe es nicht geschrieben. Ich bin neu im Bereich der regulären Ausdrücke und verstehe sie nicht so gut.

Ich habe ein paar Fragen:

1. Was ist falsch mit dem obigen RegEx?
2. Was ist ein gut RegEx für Validierung von E-Mails?

Answer 1

"Wie überprüfe ich eine E-Mail mit Regex" ist eine der häufigsten Fragen, die auftauchen, wenn es um reguläre Ausdrücke geht, und die einzige wirklich gute Antwort lautet: "Gar nicht". Diese Frage wurde bereits auf dieser Website diskutiert in muchos Anlässe . Sie müssen verstehen, dass Ihre Regex, wenn Sie sich wirklich an die Spezifikation halten wollten, etwa so aussehen würde ce . Das ist natürlich eine Ungeheuerlichkeit und dient eher dazu, zu zeigen, wie lächerlich schwierig es ist, sich an das zu halten, was man angeblich akzeptieren kann. Wenn Sie also unbedingt wissen müssen, ob die E-Mail-Adresse gültig ist, besteht die einzige Möglichkeit, dies zu überprüfen, darin, eine Nachricht an diese Adresse zu senden und zu prüfen, ob sie zurückgeschickt wird oder nicht. Andernfalls, diese Regex wird die meisten Fälle ordnungsgemäß validieren, und in vielen Situationen sind die meisten Fälle ausreichend. Darüber hinaus werden auf dieser Seite die Probleme bei der Validierung von E-Mails mit Regex erörtert.

Answer 2

Ich werde nur Ihre erste Frage beantworten, und zwar aus einer technischer Regex-Standpunkt .

Was ist falsch mit der Regex \S+@\S+\.\S+ ist, dass es das Potenzial hat, viel zu langsam ausgeführt zu werden. Was passiert, wenn jemand eine E-Mail-Zeichenkette wie die unten stehende eingibt und Sie diese validieren müssen?

a@b.cdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz0123456789

Oder noch schlimmer (ja, das sind 100 @s nach dem Punkt):

@.@@@@@@@@@@@@@@@@@@@@@@@@@ \ @@@@@@@@@@@@@@@@@@@@@@@@@ \ @@@@@@@@@@@@@@@@@@@@@@@@@ \ @@@@@@@@@@@@@@@@@@@@@@@@@

Langsamkeit kommt vor. Zuerst würde die Regex gierig so viele Zeichen wie möglich für die erste \S+ . Es wird also zunächst die gesamte Zeichenkette abgeglichen. Dann brauchen wir das @-Zeichen, also wird es zurückverfolgt, bis es eines findet. An diesem Punkt haben wir eine weitere \S+ wird also wieder alles bis zum Ende der Zeichenkette verbraucht. Dann muss er wieder zurückgehen, bis er einen Punkt findet. Können Sie sich vorstellen, wie viele Rückverfolgungen erforderlich sind, bevor die Regex schließlich bei der zweiten E-Mail-Zeichenkette fehlschlägt?

Um die Rückverfolgung zu vermeiden, schlage ich in diesem Fall die Verwendung von Klassen mit possessiven Zeichen vor, die den zusätzlichen Vorteil haben, dass sie nicht mehrere @s in einer Zeichenkette zulassen.

[^@\s]++@[^@\s.]++\.[^@\s]++

Ich habe einen schnellen Vergleich zwischen den beiden Regexen und den "100 @'s email" durchgeführt. Meine ist etwa 95 Mal schneller.

Answer 3

Was ist falsch an dem obigen RegEx?

Es wird nur nach einem '@' und einem . Es gibt eine Menge Dinge, die definitiv keine legitimen E-Mail-Adressen sind, die auf diese Kombination passen würden.

Wenn eine Person beispielsweise user@www.myWebsite.com schreibt, würde es passen, aber es ist offensichtlich ein Fehler. Ein wenig mehr Raffinesse in der Regex würde dies erkennen und dem Benutzer helfen.

Dasselbe gilt, wenn er user@myWebsite.nt eingibt - er hat 'net' falsch geschrieben. Oder er hat zwei @@s eingegeben (user@@yahoo.com / user@yahoo@yahoo.com - was eigentlich ziemlich häufig vorkommt), oder zwei Punkte (user@yahoo..com). Eine bessere Regex sollte dies erkennen.

[Obwohl bessere Prüfungen oft durch andere Fehler gestoppt werden, wie z.B. durch mehrere Punkte vor und nach dem 'at', die weggelassen oder ungültig gemacht werden können (my.name@gmail.com)]

Wenn Sie nicht wählerisch sein wollen, brauchen Sie nicht einmal eine Regex. indexOf('@') != -1 fängt die meisten Fehler ab. Nach der Überprüfung sollten Sie es besser machen.

Was ist ein gutes RegEx für die Validierung von E-Mails?

http://www.gooli.org/blog/useful-regular-expressions

http://www.regular-expressions.info/email.html

Answer 4

Ich sehe, dass @liam gepostet einen Link zum RFC822 . Aber im Einklang mit der Idee, dass Stackoverflow ein Ziel ist, und für den Fall, dass ex-parrot.com den Link entfernt, oder was haben Sie. In seiner Gesamtheit...

Mail::RFC822::Address: Regexp-basierte Adressüberprüfung

Mail::RFC822::Address ist ein Perl-Modul zur Validierung von E-Mail-Adressen gemäß der RFC 822-Grammatik . Es bietet die gleiche Funktionalität wie RFC::RFC822::Address, verwendet aber reguläre Ausdrücke in Perl anstelle des Parse::RecDescent-Parsers. Dies bedeutet, dass das Modul viel schneller geladen werden kann, da es die Grammatik beim Start nicht kompilieren muss.

Herunterladen Mail::RFC822::Adresse-0.4.tar.gz ou Lesen Sie die Dokumentation .

Die in RFC 822 beschriebene Grammatik ist erstaunlich komplex. Die Implementierung der Validierung mit regulären Ausdrücken stößt ein wenig an die Grenzen dessen, was mit regulären Ausdrücken sinnvollerweise gemacht werden kann, obwohl Perl damit gut zurechtkommt:

(?:(?:\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*)

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

Answer 5

Was ist falsch an dem obigen RegEx?
Der RFC822-Standard für E-Mail-Adressen ist sehr locker, so dass es schwierig ist, einen prägnanten regulären Ausdruck zu finden, der alle möglichen gültigen E-Mails erfasst. Die Angelegenheit wird dadurch erschwert, dass nicht jeder Mailserver/Client diesen Standard durchsetzt, so dass die tatsächlichen Daten möglicherweise

Sie können zwar raten oder ein bestimmtes Format erzwingen, aber ein Ad-hoc-Ausdruck ist so gut wie eine Garantie dafür, dass Sie entweder viele Junk-E-Mail-Adressen haben oder gültige Adressen ablehnen.

Was ist ein gutes RegEx für die Validierung von E-Mails?
Dies ist die Referenz-Regex für die Validierung gegen den RFC, die hier als Perl-Modul implementiert ist, aber auch das letzte Listing in O'Reillys "Mastering Regular Expressions" ist

Mail::RFC822::Adresse