Распознавание адреса электронной почты по регулярному выражению сложно?
https://stackoverflow.com/questions/156430
-
03-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianВопрос
Недавно я где-то прочитал, что написать регулярное выражение для соответствия адресу электронной почты с учетом всех вариаций и возможностей стандарта чрезвычайно сложно и значительно сложнее, чем можно было предположить изначально.
Может ли кто-нибудь дать некоторое представление о том, почему это так?
Существуют ли какие-либо известные и проверенные регулярные выражения, которые действительно делают это в полной мере?
Каковы хорошие альтернативы использованию регулярных выражений для сопоставления адресов электронной почты?
Решение
Для формальный спецификация электронной почты, да, это технически невозможно через Regex из-за рекурсии таких вещей, как комментарии (особенно если вы сначала не удаляете комментарии до пробелов) и различных форматов (адрес электронной почты не всегда кто-то@где-то.tld).Вы можете приблизиться (с помощью некоторых массивных и непонятных шаблонов регулярных выражений), но гораздо лучший способ проверить электронную почту — это сделать очень знакомое рукопожатие:
- они сообщают вам свой адрес электронной почты
- вы отправляете им по электронной почте ссылку для подтверждения с руководством
когда они нажимают на ссылку, вы знаете, что:
- электронная почта верна
- это существует
- они владеют этим
Гораздо лучше, чем слепо принимать адрес электронной почты.
Другие советы
Например, существует ряд модулей Perl, которые делают это.Не пытайтесь написать для этого собственное регулярное выражение.Посмотри на
Mail::VRFY выполнит проверку синтаксиса и сети (принимает ли где-то SMTP-сервер этот адрес)
https://metacpan.org/pod/Mail::VRFY
RFC::RFC822::Address - рекурсивный анализатор адресов электронной почты.
https://metacpan.org/pod/RFC::RFC822::Адрес
Mail::RFC822::Address - проверка адреса на основе регулярных выражений, на которую стоит обратить внимание только ради безумного регулярного выражения
http://ex-parrot.com/~pdw/Mail-RFC822-Address.html
Подобные инструменты существуют и для других языков.Безумное регулярное выражение ниже...
(?:(?:\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*)
Проверка адресов электронной почты в любом случае не очень полезна.Он не обнаружит распространенные опечатки или вымышленные адреса электронной почты, поскольку они имеют тенденцию синтаксически выглядеть как действительные адреса.
Если вы хотите убедиться, что адрес действителен, у вас нет другого выбора, кроме как отправить письмо с подтверждением.
Если вы просто хотите быть уверены, что пользователь вводит что-то похожее на электронное письмо, а не просто «asdf», проверьте наличие @.Более сложная проверка на самом деле не дает никакой пользы.
(Я знаю, что это не отвечает на ваши вопросы, но я думаю, что об этом все равно стоит упомянуть)
Сейчас я сопоставил тестовые примеры Кэла Хендерсона, Дэйва Чайлда, Фила Хаака, Дуга Ловелла и RFC 3696.Всего 158 тестовых адресов.
Я провел все эти тесты со всеми валидаторами, которых смог найти.Сравнение здесь: http://www.dominicsayers.com/isemail
Я постараюсь поддерживать эту страницу в актуальном состоянии по мере того, как люди совершенствуют свои валидаторы.Спасибо Кэлу, Дейву и Филу за помощь и сотрудничество в составлении этих тестов, а также за конструктивную критику. мой собственный валидатор.
Люди должны знать о опечатка в отношении RFC 3696 в частности.Три канонических примера на самом деле являются недействительными адресами.А максимальная длина адреса — 254 или 256 символов. нет 320.
Однако это не все ерунда, поскольку разрешение таких символов, как «+», может быть очень полезно для пользователей, борющихся со спамом, например. моя электронная почта+sketchysite@gmail.com (мгновенные одноразовые адреса Gmail).
Но только тогда, когда сайт это принимает.
В BNF есть контекстно-свободная грамматика, описывающая действительные адреса электронной почты в RFC-2822.Это сложно.Например:
" @ "@example.com
является действительным адресом электронной почты.Я не знаю ни одного регулярного выражения, которое бы делало это полностью;Обычно приводимые примеры требуют предварительного удаления комментариев.Я написал парсер рекурсивного спуска, чтобы сделать это полностью один раз.
Принимать или нет причудливые, необычные форматы адресов электронной почты, по моему мнению, зависит от того, что человек хочет с ними делать.
Если вы пишете почтовый сервер, вы должны быть очень точными и предельно правильными в том, что вы принимаете.Поэтому приведенное выше «безумное» регулярное выражение является подходящим.
Однако для остальных из нас мы в основном просто заинтересованы в том, чтобы то, что пользователь вводит в веб-форму, выглядело разумно и не содержало каких-либо SQL-инъекций или переполнения буфера.
Честно говоря, действительно ли кого-то волнует возможность вводить 200-символьный адрес электронной почты с комментариями, переводами строк, кавычками, пробелами, круглыми скобками и другой тарабарщиной при подписке на список рассылки, информационный бюллетень или веб-сайт?Правильный ответ таким клоунам: «Приходите позже, когда у вас будет адрес, похожий на имя пользователя@домен.tld».
Проверка, которую я делаю, состоит в том, чтобы убедиться, что существует ровно один '@';что нет пробелов, нулей или новых строк;что часть справа от «@» имеет хотя бы одну точку (но не две точки подряд);и что в нем нет кавычек, круглых скобок, запятых, двоеточий, восклицательных знаков, точек с запятой или обратной косой черты, которые, скорее всего, являются попытками взлома, чем частями фактического адреса электронной почты.
Да, это означает, что я отклоняю действительные адреса, с которыми кто-то может попытаться зарегистрироваться на моих веб-сайтах - возможно, я «неправильно» отклоняю до 0,001% реальных адресов!Я могу жить с этим.
Цитирование и другие редко используемые, но действительные части RFC усложняют задачу.Я недостаточно знаю об этой теме, чтобы дать однозначный комментарий, кроме «это сложно», но, к счастью, другой Люди имеют написано об этом подробно.
Что касается допустимого регулярного выражения для него, модуль Perl Mail::Rfc822::Address содержит регулярное выражение, которое, очевидно, будет работать - но только если какие-либо комментарии уже заменены пробелами.(Комментарии на адрес электронной почты?Вы понимаете, почему это сложнее, чем можно было ожидать...)
Конечно, упрощенные регулярные выражения, которых много в других местах, проверят почти каждый адрес электронной почты, который действительно используется...
Некоторые разновидности регулярных выражений могут фактически соответствовать вложенным скобкам (например, совместимым с Perl).Тем не менее, я видел регулярное выражение, которое утверждает, что оно правильно соответствует RFC 822, и это были две страницы текста без каких-либо пробелов.Поэтому лучший способ определить действительный адрес электронной почты — отправить на него электронное письмо и посмотреть, работает ли он.
Просто чтобы добавить регулярное выражение, которое менее безумно, чем перечисленное @mmaibaum:
^[a-zA-Z]([.]?([a-zA-Z0-9_-]+)*)?@([a-zA-Z0-9\-_]+\.)+[a-zA-Z]{2,4}$
Он не является безупречным и, конечно, не охватывает всю спецификацию электронной почты, но он неплохо справляется с удовлетворением большинства основных требований.Более того, это в некоторой степени понятно и может быть отредактировано.
Взято из обсуждения на сайте HouseOfFusion.com, ресурс ColdFusion мирового класса.
Простой и хороший способ проверить адреса электронной почты в Java — использовать EmailValidator Apache. Валидатор Commons библиотека.
Я всегда проверял адрес электронной почты в форме ввода на соответствие чему-то подобному перед отправкой электронного письма - даже если вы заметили только несколько опечаток.Вероятно, вы не захотите писать автоматический сканер для уведомлений об ошибке доставки.:-)
Это действительно сложно, потому что в соответствии со спецификацией электронной почты в адресе электронной почты может быть много вещей, которые могут быть действительными. RFC 2822.То, что вы обычно не видите, например +, является вполне допустимыми символами для адреса электронной почты.согласно спец.
Адресам электронной почты посвящен целый раздел на сайте http://regexlib.com, что является отличным ресурсом.Я бы посоветовал вам определить, какие критерии для вас важны, и найти тот, который им соответствует.Большинству людей действительно не нужна полная поддержка всех возможностей, предусмотренных спецификацией.
Если вы используете .NET Framework, просто попробуйте создать экземпляр MailAddress объект и поймать FormatException если он взорвется, или вытащить Address если это удастся.Не вдаваясь в какую-либо ерунду о производительности перехвата исключений (действительно, если это происходит только в одной веб-форме, это не будет иметь большого значения), MailAddress Класс в .NET Framework проходит довольно полный процесс анализа (он не использует RegEx).Откройте Reflector и найдите MailAddress и MailBnfHelper.ReadMailAddress() чтобы увидеть все причудливые вещи, которые он делает.Кто-то умнее меня потратил много времени на создание этого парсера в Microsoft. Я собираюсь использовать его, когда отправляю электронное письмо на этот адрес, так что я мог бы также использовать его и для проверки входящего адреса.
Многие пытались, и многие приблизились к этому.Возможно, вы захотите прочитать статья в Википедии, и некоторый другие.
В частности, вам следует помнить, что многие веб-сайты и серверы электронной почты имеют упрощенную проверку адресов электронной почты, поэтому, по сути, они не полностью реализуют стандарт.Однако этого достаточно, чтобы электронная почта работала постоянно.
Попробуй это:
"(?:[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])+)\])"
Взгляни здесь для подробностей.
Однако вместо реализации стандарта RFC822, возможно, было бы лучше взглянуть на него с другой точки зрения.На самом деле не имеет значения, что говорит стандарт, если почтовые серверы не отражают стандарт.Поэтому я бы сказал, что было бы лучше подражать тому, что делают самые популярные почтовые серверы при проверке адресов электронной почты.
В этом классе для Java есть валидатор:http://www.leshazlewood.com/?p=23
Это пишет создатель Shiro (формально Ki, формально JSecurity)
Плюсы и минусы проверки валидности адреса электронной почты:
Существует два типа регулярных выражений, которые проверяют электронную почту:
- Те, которые слишком свободны.
Те, которые слишком строги.
Регулярное выражение не может соответствовать всем действительным адресам электронной почты и не соответствовать недействительным адресам электронной почты, поскольку некоторые строки могут выглядеть как действительные адреса электронной почты, но на самом деле не попадать ни в какой почтовый ящик.Единственный способ проверить, действительно ли электронное письмо действительно, — это отправить электронное письмо на этот адрес и посмотреть, получите ли вы какой-то ответ.Учитывая это, регулярные выражения, которые слишком строги при сопоставлении электронных писем, похоже, на самом деле не имеют особого смысла.
Я думаю, что большинство людей, которые запрашивают регулярное выражение для электронной почты, ищут первый вариант — слишком свободные регулярные выражения.Они хотят протестировать строку и посмотреть, похожа ли она на электронное письмо. Если это точно не электронное письмо, они могут сказать пользователю:«Эй, вы должны оставить здесь электронное письмо, и это определенно недействительное электронное письмо.Возможно, вы не заметили, что это поле предназначено для электронной почты, или, возможно, здесь опечатка».
Если пользователь вводит строку, которая очень похожа на действительное электронное письмо, но на самом деле им не является, то это проблема, которую должна решать другая часть приложения.
Может ли кто-нибудь дать некоторое представление о том, почему это так?
Да, это чрезвычайно сложный стандарт, который допускает множество вещей, которые сегодня никто на самом деле не использует.:)
Существуют ли какие-либо известные и проверенные регулярные выражения, которые действительно делают это в полной мере?
Вот одна попытка полностью разобрать весь стандарт...
http://ex-parrot.com/~pdw/Mail-RFC822-Address.html
Каковы хорошие альтернативы использованию регулярных выражений для сопоставления адресов электронной почты?
Я думаю, используя для этого существующую структуру на любом языке, который вы используете?Хотя они, вероятно, будут использовать регулярное выражение внутри себя.Это сложная строка.Регулярные выражения предназначены для анализа сложных строк, так что это действительно лучший выбор.
Редактировать:Я должен добавить, что регулярное выражение, на которое я ссылался, было просто для развлечения.Я не одобряю использование такого сложного регулярного выражения - некоторые люди говорят, что «если ваше регулярное выражение состоит из более чем одной строки, в нем гарантированно есть ошибка».Я дал ссылку на него, чтобы проиллюстрировать, насколько сложен стандарт.
Добавление в Уэйнответ, есть также раздел, посвященный www.regular-expressions.info посвящен электронной почте, с несколькими образцами.
Всегда можно задаться вопросом, стоит ли оно того или на самом деле любой регулярное выражение, покрывающее менее 100%, только способствует ложному чувству безопасности.
В конце концов, на самом деле отправка электронная почта — это то, что обеспечит реальную окончательную проверку.(-вы узнаете, есть ли на вашем почтовом сервере ошибки;-)
Для полноты этого поста отметим, что в PHP также есть встроенная функция языка для проверки электронной почты.
Для PHP используйте хороший filter_var с конкретным типом проверки EMAIL :)
Больше никаких безумных регулярных выражений электронной почты в PHP :D
var_dump(filter_var('bob@example.com', FILTER_VALIDATE_EMAIL));
