Что не так с этим RegEx для проверки электронной почты?

Вот регулярное выражение для проверки писем -\[email protected]\S+\.\S+Я не написал это. Я новичок в Регулярных выражениях и не очень хорошо их понимаю.

У меня есть пара вопросов:

What's wrong with the above RegEx? What's a good RegEx for validating emails?
 Alan Moore03 июл. 2009 г., 02:45
Что вы имеете в виду, не допускает? \ S совпаденияany непробельный символ.
 Michael Myers♦02 июл. 2009 г., 22:49
Что касается того, что с ним не так: во-первых, он не допускает точек в первой части. Это дисквалифицирует два из трех моих адресов электронной почты. Кроме того, он допускает только одну точку во второй части, которая дисквалифицирует домены, такие как «.co.uk».
 mipadi02 июл. 2009 г., 22:54
Это также не допускает "+" войдите в логины, что является законным. Часть после "+" знак игнорируется, но многие люди используют его для фильтрации писем. Например, если имя пользователя «[email protected]"», то кто-то может использовать «[email protected]" как электронная почта Amazon, позволяющая им легко фильтровать почту (или отслеживать, передает ли конкретный сервис свой адрес электронной почты другому сервису).
 Michael Myers♦02 июл. 2009 г., 22:43
Кто хочет быть первым, чтобы опубликовать регулярное выражение электронной почты на трех страницах?
 Bart Kiers20 нояб. 2009 г., 23:44
Действительно, Алан прав.mipadi а такжеmmyersвы оба не правы:\S соответствует как. (точка) и+.

Ответы на вопрос(5)

@liam отправилссылка на RFC822, Но, в соответствии с идеей, что stackoverflow является пунктом назначения, и incase ex-parrot.com снимает ссылку, или что там у вас. На этом все ...

Mail::RFC822::Address: regexp-based address validation

Mail :: RFC822 :: Address - это модуль Perl для проверки адресов электронной почты в соответствии сRFC 822 грамматика, Он обеспечивает ту же функциональность, что и RFC :: RFC822 :: Address, но использует регулярные выражения Perl, а не Parse :: RecDescent parser. Это означает, что модуль загружается гораздо быстрее, так как не нужно компилировать грамматику при запуске.

Download Mail::RFC822::Address-0.4.tar.gz or read the do,cumentation.

Грамматика, описанная в RFC 822, удивительно сложна. Реализация проверки с помощью регулярных выражений несколько расширяет границы того, что целесообразно делать с регулярными выражениями, хотя Perl хорошо справляется:

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

Это регулярное выражение будет проверять только адреса, у которых были удалены все комментарии и заменены пробелами (это делает модуль).

technical regex point of view.

Что не так с регулярным выражением\[email protected]\S+\.\S+является то, что он может выполнять слишком медленно. Что произойдет, если кто-то введет строку электронной почты, подобную приведенной ниже, и вам необходимо ее подтвердить?

[email protected]

Или еще хуже (да, это 100 @ после точки):

@[email protected]@@@@@@@@@@@@@@@@@@@@@@@@ \ @@@@@@@@@@@@@@@@@@@@@@@@@ \ @@@@@@@@@@@@@@@@@@@@@@@@@ \ @@@@@@@@@@@@@@@@@@@@@@@@@

Медлительность случается. Сначала регулярное выражение будет жадно соответствовать как можно большему числу символов для первого\S+, Таким образом, он изначально будет соответствовать всей строке. Затем нам нужен символ @, поэтому он будет возвращаться, пока не найдет его. В этот момент у нас есть еще один\S+Итак, снова он будет потреблять все до конца строки. Затем он должен вернуться назад, пока не найдет точку. Можете ли вы представить, сколько времени происходит откат до того, как регулярное выражение окончательно завершится неудачно во второй строке электронной почты?

Чтобы убрать возврат, я предлагаю использовать притяжательные классы символов в этом случае, которые имеют дополнительное преимущество, заключающееся в том, что не допускается использование нескольких @ в одной строке.

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

Я сделал быстрый тест для двух регулярных выражений в отношении & # x201C; 100 @ 's email & # x201D ;. Мой примерно в 95 раз быстрее.

 20 нояб. 2009 г., 23:00
Эй, Гирт, приятно видеть тебя здесь. О времени выполнения регулярного выражения: я не думаю, что это имеет большое значение в этом случае, если только вы не собираетесь проверять тысячи адресов за очень короткое время или если длина адреса составляет тысячи символов. (но у нас было это обсуждение раньше :)) С уважением, Барт (prometheuzz).
 29 мар. 2012 г., 18:10
Я должен задаться вопросом, насколько медленнее допустимое регулярное выражение, чем огромное регулярное выражение RFC, я бы предположил, что оно все еще намного быстрее, поэтому производительность в этом случае не кажется серьезной проблемой. По сути, 95 раз медленнее, чем 1 миллисекунда, всего 95 миллисекунд, пренебрежимо мало. Так о каком замедлении мы говорим здесь?

What's wrong with the above RegEx?
поэтому трудно найти краткое регулярное выражение, которое бы охватывало все возможные действительные электронные письма. Дело осложняется тем, что не каждый почтовый сервер / клиент применяет этот стандарт, поэтому фактические данные могут быть

Хотя вы, конечно, можете угадать или применить конкретный формат, написание специального выражения является гарантией того, что у вас будет много нежелательных адресов электронной почты или отрицание действительных.

What's a good RegEx for validating emails?
Это ссылочное регулярное выражение для проверки соответствия RFC, оно реализовано здесь как модуль perl, но также является окончательным списком в O 'Reillys' Мастеринг регулярных выражений & quot;

Mail :: RFC822 :: Адрес

Он только проверяет наличие «@»; и Есть много вещей, которые определенно не являются законными адресами электронной почты, которые соответствуют этой комбинации.

Например, если человек пишет [email protected], он будет соответствовать, но это, очевидно, ошибка. Немного больше изощренности в регулярном выражении поймает его и поможет пользователю.

То же самое, если он введет в [email protected] - он неправильно написал "net". Или он добавил две @@ (user @@ yahoo.com / user @ yahoo @ yahoo.com - что довольно часто встречается) или две точки (user @ yahoo..com). Лучшее регулярное выражение должно поймать их.

[Хотя лучшие проверки часто останавливаются на других ошибках, такие допустимые множественные точки до и после 'at' apos; которые могут быть удалены или признаны недействительными ([email protected])]

Если вы не хотите быть разборчивым, вам даже не нужно регулярное выражение. indexOf («@»)! = -1 перехватит большинство ошибок. После проверки вы должны сделать лучше.

What's a good RegEx for validating emails?

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

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

 02 июл. 2009 г., 22:53
[email protected] является действующим адресом электронной почты.
 03 июл. 2009 г., 00:23
Весьма часто иметь несколько точек во второй половине письма, например, [email protected]
 02 июл. 2009 г., 22:56
В самом деле?! Если я сделаю [email protected], получу ли я это? Хотя теперь, когда я думаю об этом, что-то, заканчивающееся на .nt, может быть технически тоже. Все еще правильно поймать и проверить оба вышеперечисленных.
Решение Вопроса

& quot; Как проверить электронную почту с помощью regex & quot; это один из наиболее популярных вопросов, которые возникают, когда речь идет о регулярных выражениях, и единственно реальный хороший ответ - «вы не понимаете».в много случаи, Что вы должны понять, так это то, что если вы действительно хотите следовать спецификации, ваше регулярное выражение будет выглядеть примерно так:этот, Очевидно, что это чудовище и больше упражнение, демонстрирующее, насколько нелепо трудно придерживаться того, что вы должны быть в состоянии принять. Имея это в виду, если вам абсолютно необходимо знать, что адрес электронной почты является действительным, единственный реальный способ проверить это - это отправить сообщение на адрес электронной почты и проверить, является ли он отскочившим или нет. Иначе,это регулярное выражение будет правильно проверять большинство случаев, и в большинстве случаев достаточно случаев. Кроме того, на этой странице будут обсуждаться проблемы с проверкой писем с помощью регулярных выражений.

Ваш ответ на вопрос