Распознавание Regexp адреса электронной почты трудно?

Для полноты этого сообщения также для PHP существует встроенная функция языка для проверки электронных писем.

Для Использования PHP хороший filter_var с определенным ПОЧТОВЫМ типом проверки:)

Никакая более безумная электронная почта regexes в php: D

var_dump(filter_var('bob@example.com', FILTER_VALIDATE_EMAIL));

http://www.php.net/filter_var

Многие попробовали, и многие приближаются. Можно хотеть читать статья Википедии, и [приблизительно 111] другие .

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

Добавление к Wayne ответ с, существует также раздел по www.regular-expressions.info, выделенный электронной почте с несколькими образцами.

можно всегда подвергать сомнению, стоит ли это того или если на самом деле любой меньше чем 100%-покрытий regexp только способствуют ложному чувству безопасности.

В конце, на самом деле отправка электронная почта - то, что обеспечит реальную заключительную проверку. (-you'll узнают, имеет ли Ваш mailserver ошибки;-)

кто-либо может обеспечить некоторое понимание относительно того, почему это?

Да, это - чрезвычайно сложный стандарт, который позволяет много материала, который никто действительно не использует сегодня.:)

там кто-либо известные и доказанные regexps, которые на самом деле делают это полностью?

Вот одна попытка проанализировать целый стандарт полностью...

http://ex-parrot.com/~pdw/Mail-RFC822-Address.html

, Каковы некоторые хорошие альтернативы использованию regexps для соответствия адресам электронной почты?

Используя существующую платформу для него на любом языке, который Вы используете, я предполагаю? Хотя те будут, вероятно, использовать regexp внутренне. Это - сложная строка. Regexps разработаны для парсинга сложных строк, так, чтобы действительно был лучший выбор.

Редактирование : Я должен добавить, что regexp, с которым я связался, был только для забавы. Я не подтверждаю использование комплекса regexp как этот - некоторые люди говорят, что, "если Ваш regexp является больше чем одной строкой, это, как гарантируют, будет иметь ошибку в нем где-нибудь". Я связался с ним, чтобы проиллюстрировать, насколько сложный стандарт.

Попробуйте этого:

"(?:[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, возможно, было бы лучше посмотреть на него с другой точки зрения. Действительно не имеет значения, что говорит стандарт, не зеркально отражают ли почтовые серверы стандарт. Таким образом, я утверждал бы, что будет лучше подражать тому, что самые популярные почтовые серверы делают при проверке адресов электронной почты.

Это действительно твердо, потому что существует много вещей, которые могут быть допустимыми в адресе электронной почты согласно почтовой Спецификации, RFC 2822 . Вещами, что Вы обычно не рассматриваете такой как +, являются совершенно допустимые символы для адреса электронной почты.. согласно спецификации.

существует весь раздел, посвященный адресам электронной почты по телефону http://regexlib.com , который является большим ресурсом. Я предложил бы, чтобы Вы определили, какие критерии имеет значение для Вас, и найдите тот, который соответствует. Большинству людей действительно не нужна полная поддержка всех возможностей, позволенных спецификацией.

Некоторые ароматы regex могут на самом деле соответствовать вложенным скобкам (например, Perl совместимые). Однако я видел regex, который утверждает, что правильно соответствовал RFC 822, и это были две страницы текста без любого пробела. Поэтому лучший способ обнаружить адрес действующего адреса электронной почты состоит в том, чтобы послать электронное письмо ему и видеть, работает ли это.

Заключение в кавычки и различные другие редко используемые, но допустимые части RFC затрудняет. Я не знаю достаточно об этой теме для комментария окончательно, кроме "он тверд" - но к счастью другой , люди имеют записанный об этом подробно.

относительно допустимого regex для него, Почты Perl:: Rfc822:: модуль Адреса содержит регулярное выражение, которое будет, по-видимому, работать - но только если любые комментарии уже были заменены пробелом. (Комментарии в адресе электронной почты? Вы видите, почему это более твердо, чем можно было бы ожидать...)

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

Существует контекстно-свободная грамматика в BNF, который описывает адреса действующего адреса электронной почты в RFC 2822 . Это сложно. Например:

" @ "@example.com

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

Это не вся ерунда, хотя, поскольку разрешение символов такого как '+' может быть очень полезно для пользователей, сражающихся со спамом, например, myemail+sketchysite@gmail.com ( мгновенные доступные адреса Gmail ).

Только, когда сайт принимает его все же.

Признать ли, что причудливые, редкие форматы адреса электронной почты зависят, по-моему, на том, что каждый хочет сделать с ними.

, Если Вы пишете почтовый сервер, необходимо быть очень точными и мучительно исправить, в каком Вы принимаете. "Безумный" regex, заключенный в кавычки выше, является поэтому соответствующим.

Для остальной части нас, тем не менее, мы главным образом просто интересуемся обеспечением, что что-то, что пользователь вводит в веб-форме, выглядит разумным и не имеет своего рода внедрения SQL или переполнения буфера в нем.

Откровенно говоря, кто-либо действительно заботится о разрешении кому-то ввести адрес электронной почты с 200 символами с комментариями, новыми строками, кавычками, пробелами, круглыми скобками или другим мусором когда регистрация для списка рассылки, новостной рассылки или веб-сайта? Надлежащий ответ таким клоунам "Возвращен позже, когда у Вас есть адрес, который похож на username@domain.tld".

проверка, которую я делаю, состоит из обеспечения, что существует точно один; то, что нет никаких пробелов, аннулирует или новые строки; то, что часть направо от имеет по крайней мере одну точку (но не две точки подряд); и это там не кавычки, круглые скобки, запятые, двоеточия, восклицания, точки с запятой или обратные косые черты, все из которых, более вероятно, будут попытками хакерства, чем части фактического адреса электронной почты.

Да, это означает, что я отклоняю допустимые адреса, в которых кто-то мог бы попытаться зарегистрироваться на моих веб-сайтах - возможно, я "неправильно" отклоняю целый 0,001% реальных адресов! Я могу жить с этим.

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

, Если Вы хотите быть уверенными, адрес допустим, у Вас нет выбора, кроме как отправить почту подтверждения.

, Если Вы просто хотите быть уверенными, что вводы данных пользователем что-то, что похоже на электронное письмо, а не просто "asdf", затем проверьте на. Более сложная проверка действительно не предоставляет преимущества.

(я знаю, это не отвечает на Ваши вопросы, но я думаю, что это стоит упомянуть так или иначе)

Я теперь сопоставил тестовые сценарии от Cal Henderson, Dave Child, Phil Haack, Doug Lovell и тестовых адресов RFC 3696. 158 всего.

я запустил все эти тесты против всех блоков проверки допустимости, которые я мог найти. Сравнение здесь: http://www.dominicsayers.com/isemail

я попытаюсь усовершенствовать эту страницу, поскольку люди улучшают свои блоки проверки допустимости. Благодаря Cal, Dave и Phil для их справки и сотрудничества в компиляции этих тестов и конструктивной критики мой собственный блок проверки допустимости .

Люди должны знать эти опечатки против RFC 3696 в частности. Тремя из канонических примеров являются на самом деле недопустимые адреса. И максимальная длина адреса является 254 или 256 символами, не 320.

Только для добавления regex, который является менее сумасшедшим, чем тот, перечисленный @mmaibaum:

^[a-zA-Z]([.]?([a-zA-Z0-9_-]+)*)?@([a-zA-Z0-9\-_]+\.)+[a-zA-Z]{2,4}$ 

Это не является пуленепробиваемым, и конечно не покрывает всю почтовую спецификацию, но это действительно делает достойное задание покрытия наиболее основных требований. Еще лучше это несколько понятно, и может быть отредактировано.

Запертый из обсуждения в HouseOfFusion.com , ресурс ColdFusion мирового класса.

Существует много модулей Perl (например), которые делают это. Не пытайтесь записать свой собственный regexp, чтобы сделать это. Взгляд

Mail::VRFY сделает синтаксис, и сетевые проверки (делает и сервер SMTP где-нибудь принимают этот адрес)

https://metacpan.org/pod/Mail:: VRFY

RFC::RFC822::Address - синтаксический анализатор адреса электронной почты рекурсивного спуска.

https://metacpan.org/pod/RFC:: RFC822:: Адрес

Mail::RFC822::Address - находящаяся в regexp проверка адреса, которая стоит посмотреть на только для безумных инструментов regexp

http://ex-parrot.com/~pdw/Mail-RFC822-Address.html

Similar, существуют для других языков. Безумный regexp ниже...

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

Легкий и хороший способ проверить адреса электронной почты в Java состоит в том, чтобы использовать EmailValidator библиотеки Apache Commons Validator .

я всегда проверял бы адрес электронной почты во входную форму против чего-то вроде этого прежде, чем послать электронное письмо - даже если Вы только находите некоторые опечатки. Вы, вероятно, не хотите писать, что автоматизированный сканер для "доставки привел к сбою" письма уведомления.:-)

Если вы работаете на .NET Framework, просто попробуйте инстанцировать объект MailAddress и перехватить FormatException, если он взорвется, или вытащить Address, если это удастся. Не вдаваясь в чушь о производительности перехвата исключений (на самом деле, если это только на одной веб-форме, это не будет иметь такого большого значения), класс MailAddress в .NET-фреймворке проходит довольно полный процесс разбора (он не использует RegEx). Откройте отражатель и ищите MailAddress и MailBnfHelper.ReadMailAddress(), чтобы увидеть все причудливые вещи, которые он делает. Кто-то умнее меня потратил много времени на сборку этого парсера в Microsoft, я собираюсь использовать его, когда на самом деле посылаю электронное письмо на этот адрес, так что я мог бы также использовать его для проверки входящего адреса.

В этом классе для Java есть валидатор: http://www.leshazlewood.com/?p=23

Это написано создателем Shiro (формально Ki, формально JSecurity)

Плюсы и минусы тестирования на валидность адреса электронной почты:

Существует два типа регулярных выражений, которые проверяют электронную почту:

1. Слишком свободные.
2. Слишком строгие.

Регулярное выражение не может совпадать со всеми действительными адресами электронной почты и с недействительными адресами электронной почты, поскольку некоторые строки могут выглядеть как действительные адреса электронной почты, но фактически не попадают в чьи-либо почтовые ящики. Единственный способ проверить, действительно ли электронное письмо является действительным, - это отправить электронное письмо на этот адрес и посмотреть, получите ли вы какой-то ответ. Имея это в виду, регулярные выражения, которые слишком строгие для сопоставления электронных писем, на самом деле, похоже, не имеют особой цели.

Я думаю, что большинство людей, которые запрашивают регулярное выражение электронной почты, ищут первый вариант - слишком свободные регулярные выражения. Они хотят проверить строку и посмотреть, выглядит ли она как электронное письмо, если это определенно не электронное письмо, тогда они могут сказать пользователю: «Эй, вы должны поместить сюда электронное письмо, и это определенно недействительный e-mail.Возможно, вы не осознавали, что это поле предназначено для электронной почты, или, возможно, здесь есть опечатка ».

Если пользователь вводит строку, которая очень похожа на действительное электронное письмо, но на самом деле это не так , то эту проблему должна решать другая часть приложения.