Как я могу проверить адрес электронной почты с помощью регулярного выражения?

С годами я постепенно разработал regular expression, который 9X_email правильно проверяет большинство адресов электронной 9X_validation почты, предполагая, что они не используют 9X_regular-expressions IP-адрес в качестве серверной части.

Я использую 9X_regular-expressions его в нескольких программах PHP, и в большинстве 9X_regex случаев он работает. Однако время от времени 9X_email-validation со мной связывается кто-то, у кого проблемы 9X_validation с сайтом, который его использует, и мне 9X_email приходится вносить некоторые изменения (совсем 9X_email-validation недавно я понял, что не разрешаю четырехзначный 9X_email TLDs).

Какое самое лучшее регулярное выражение для проверки электронных писем вы использовали или видели?

Я видел несколько решений, в которых используются 9X_email функции, использующие несколько более коротких 9X_regular-expressions выражений, но я бы предпочел иметь одно 9X_regular-expressions длинное сложное выражение в простой функции 9X_mail вместо нескольких коротких выражений в более 9X_string-parsing сложной функции.

3974
2

  • Регулярное выражение, которое может проверить правильность форматирования IDNA, не подходит для stackexchange. (правила канонизации были действительно извилистыми и осо ...
68
Общее количество ответов: 68

Ответ #1

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

fully RFC 822 compliant regex неэффективен и непонятен из-за своей длины. К 9X_mail счастью, RFC 822 заменялся дважды, и текущая 9X_email спецификация адресов электронной почты - RFC 5322. RFC 9X_email-integration 5322 приводит к регулярному выражению, которое 9X_regular-expressions можно понять, если изучить его в течение 9X_email-validation нескольких минут, и которое достаточно эффективно 9X_regular-expressions для фактического использования.

Одно регулярное 9X_mail выражение, совместимое с RFC 5322, можно 9X_form-validation найти вверху страницы по адресу http://emailregex.com/, но оно 9X_email-integration использует шаблон IP-адреса, который перемещается 9X_form-validation по Интернету с ошибкой, которая позволяет 9X_regular-expressions 00 использовать любое из десятичных байтовых 9X_form-validation значений без знака в адрес, разделенный 9X_mail точками, что недопустимо. Остальная часть 9X_regular-expressions соответствует грамматике RFC 5322 и проходит 9X_string-parsing несколько тестов с использованием grep -Po, включая 9X_email-validation имена доменов, IP-адреса, неверные адреса 9X_regular-expression и имена учетных записей с кавычками и без 9X_form-validation них.

Исправляя ошибку 00 в шаблоне IP, мы получаем 9X_form-validation работающее и довольно быстрое регулярное 9X_validation выражение. (Очистите визуализированную версию, а 9X_email не уценку, для фактического кода.)

(?: [a-z0-9! # $% & '* + / =? ^ _ `{|} ~ -] + (?: \. [a-z0-9! # $% &' * + / =? ^ _ `{|} ~ -] +) * |" (?: [\ x01- \ x08 9X_email-integration \ x0b \ x0c \ x0e- \ x1f \ x21 \ x23- \ x5b 9X_regexp \ x5d- \ x7f] | \\ [\ x01- \ x09 \ x0b \ x0c 9X_mail \ x0e- \ x7f]) * ") @ (?: (?: [a-z0-9] (?: [a-z0-9 9X_email-integration -] * [ a-z0-9])? \.) + [a-z0-9] (?: [a-z0-9 9X_email-integration -] * [a-z0-9])? | \ [(? :(? :( 2 (5 [0-5] | [0-4] [0-9]) | 1 9X_mail [0-9] [0-9] | [1-9]? [0-9])) \.) { 3} (? :( 2 9X_email (5 [0-5] | [0-4] [0-9]) | 1 [0-9] [0-9] | [1-9]? [0-9] ) | [a-z0-9 9X_email-validation -] * [a-z0-9]: (?: [\ x01- \ x08 \ x0b \ x0c 9X_email-validation \ x0e- \ x1f \ x21- \ x5a \ x53- \ x7f] | \ \ [\ x01- \ x09 9X_string-parsing \ x0b \ x0c \ x0e- \ x7f]) +) \])

или:

(?:[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])?|\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-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])+)\])

Вот 9X_validation diagram из finite state machine для вышеуказанного регулярного выражения, которое 9X_regexp более понятно, чем само регулярное выражение 9X_Как я могу проверить адрес электронной почты с помощью регулярного выражения?_form-validation

Более 9X_string-parsing сложные шаблоны в Perl и PCRE (библиотека 9X_regular-expression регулярных выражений, используемая, например, в 9X_regular-expression PHP) могут correctly parse RFC 5322 without a hitch. Python и C# тоже могут это 9X_email-integration делать, но они используют синтаксис, отличный 9X_email-integration от первых двух. Однако, если вы вынуждены 9X_form-validation использовать один из многих менее мощных 9X_mail языков сопоставления с образцом, лучше всего 9X_email использовать настоящий синтаксический анализатор.

Также 9X_mail важно понимать, что его проверка в соответствии 9X_email-integration с RFC абсолютно ничего не говорит о том, действительно 9X_regexp ли этот адрес существует в указанном домене 9X_form-validation или является ли человек, вводящий адрес, его 9X_string-parsing истинным владельцем. Так люди все время 9X_form-validation подписываются на списки рассылки. Для исправления 9X_email-integration требуется более изящный вид проверки, включающий 9X_email отправку на этот адрес сообщения, содержащего 9X_regular-expression токен подтверждения, предназначенный для 9X_string-parsing ввода на той же веб-странице, что и адрес.

Жетоны 9X_regexp подтверждения - единственный способ узнать, что 9X_validation вы получили адрес человека, вводящего его. Вот 9X_regular-expressions почему большинство списков рассылки теперь 9X_regular-expression используют этот механизм для подтверждения 9X_string-parsing регистрации. В конце концов, любой может 9X_regular-expressions записать president@whitehouse.gov, и это даже будет проанализировано 9X_regular-expressions как законное, но вряд ли это будет человек 9X_regexp на другом конце.

Для PHP вам не следует не использовать 9X_regular-expression шаблон, указанный в Validate an E-Mail Address with PHP, the Right Way, из которого я цитирую:

Существует 9X_regular-expression некоторая опасность того, что обычное использование 9X_mail и широко распространенное неаккуратное кодирование 9X_string-parsing установят фактический стандарт для адресов 9X_form-validation электронной почты, который будет более строгим, чем 9X_validation зарегистрированный формальный стандарт.

Это 9X_validate не лучше, чем все другие шаблоны, не относящиеся 9X_form-validation к RFC. Он даже не настолько умен, чтобы 9X_form-validation обрабатывать даже RFC 822, не говоря уже о RFC 9X_validation 5322. Однако This one может.

Если вы хотите проявить 9X_regular-expressions фантазию и педантичность, implement a complete state engine. Регулярное выражение 9X_email-integration может действовать только как элементарный 9X_email фильтр. Проблема с регулярными выражениями 9X_email-validation заключается в том, что сообщать кому-либо 9X_regexp о том, что их совершенно действительный 9X_string-parsing адрес электронной почты недействителен (ложное 9X_regexp срабатывание), потому что ваше регулярное 9X_string-parsing выражение не может его обработать, просто 9X_regular-expressions грубо и невежливо с точки зрения пользователя. Механизм 9X_string-parsing состояний для этой цели может как проверять, так 9X_email и даже исправлять адреса электронной почты, которые 9X_email-integration в противном случае считались бы недействительными, поскольку 9X_email-validation он разбирает адрес электронной почты в соответствии 9X_regular-expression с каждым RFC. Это позволяет получить потенциально 9X_form-validation более приятный опыт, например

Указанный адрес 9X_mail электронной почты "myemail @ address, com" недействителен. Вы 9X_email-validation имели в виду myemail@address.com?

См. также 9X_form-validation Validating Email Addresses, включая комментарии. Или Comparing E-mail Address Validating Regular Expressions.

9X_Как я могу проверить адрес электронной почты с помощью регулярного выражения?_validate

Debuggex Demo

3138
9

  • Благодаря сообщению, теперь мне нужно вернуться к терапии из-за травмы, которую мне дали попытки прочитать ...

Ответ #2

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Не следует использовать регулярные выражения 9X_email-integration для проверки адресов электронной почты.

Вместо 9X_string-parsing этого в C# используйте класс MailAddress, например:

try {
    address = new MailAddress(address).Address;
} catch(FormatException) {
    // address is invalid
}

Класс 9X_mail MailAddress использует синтаксический анализатор BNF 9X_email-validation для проверки адреса в полном соответствии 9X_string-parsing с RFC822.

Если вы планируете использовать 9X_regular-expressions MailAddress для проверки адреса электронной почты, имейте 9X_string-parsing в виду, что этот подход также принимает 9X_email-validation часть отображаемого имени адреса электронной 9X_form-validation почты, и это может быть не совсем то, чего 9X_regexp вы хотите достичь. . Например, он принимает 9X_form-validation эти строки как действительные адреса электронной 9X_regular-expressions почты:

  • "user1@hotmail.com; user2@gmail.com"
  • "user1@hotmail.com; user2@gmail.com; user3@company.com"
  • "Отображаемое имя пользователя user3@company.com"
  • "user4 @ company.com"

В некоторых из этих случаев только 9X_string-parsing последняя часть строк анализируется как 9X_string-parsing адрес; остальное перед этим - отображаемое 9X_mail имя. Чтобы получить простой адрес электронной 9X_mail почты без отображаемого имени, вы можете 9X_regexp сравнить нормализованный адрес с исходной 9X_regexp строкой.

bool isValid = false;

try
{
    MailAddress address = new MailAddress(emailAddress);
    isValid = (address.Address == emailAddress);
    // or
    // isValid = string.IsNullOrEmpty(address.DisplayName);
}
catch (FormatException)
{
    // address is invalid
}

Кроме того, адрес с точкой в ​​конце, например 9X_string-parsing user@company., также принимается MailAddress.

Если вы 9X_form-validation действительно хотите использовать регулярное 9X_validation выражение, here it is:

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

837
9

  • Я думаю, что это вроде ... не работает ... для более простых идентификаторов. a @ b не проверяет. ar@b.com соответствует только до ar @ b, .com не совпадает. Однако что-то вроде «Я - это я» ...

Ответ #3

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Этот вопрос задают много, но я думаю, вам 9X_validate следует сделать шаг назад и спросить себя: почему вы 9X_regular-expression хотите проверять адреса электронной почты 9X_email синтаксически? В чем на самом деле выгода?

  • Он не распознает типичные опечатки.
  • Это не мешает людям вводить недействительные или выдуманные адреса электронной почты или вводить чужой адрес в этом отношении.

Если 9X_form-validation вы хотите проверить правильность электронного 9X_regex письма, у вас нет другого выбора, кроме 9X_validation как отправить письмо с подтверждением и 9X_validation попросить пользователя ответить на него. Во 9X_form-validation многих случаях вам все равно придется отправить 9X_regular-expressions письмо с подтверждением по соображениям 9X_mail безопасности или по этическим соображениям 9X_regex (чтобы вы не могли, например, подписать 9X_email-validation кого-либо на службу против его воли).

599
4

  • Возможно, стоит проверить, что они ввели что-то @ something в поле при проверке на стороне клиента, просто чтобы отловить простые о ...

Ответ #4

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Все зависит от того, насколько точным вы 9X_validation хотите быть. Для моих целей, когда я просто 9X_validate пытаюсь не допускать таких вещей, как bob @ aol.com (пробелы 9X_string-parsing в электронных письмах) или steve (вообще без 9X_regular-expression домена) или mary@aolcom (без точки перед .com), я использую 9X_validation

/^\S+@\S+\.\S+$/

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

В это регулярное выражение 9X_regex можно внести любое количество изменений 9X_validation (и некоторые из них есть в комментариях 9X_validation к этому ответу), но это просто и легко понять, и 9X_string-parsing это отличная первая попытка.

511
12

  • Да, верно, это не RFC-совместимое, но обычно ...

Ответ #5

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Это зависит от того, что вы имеете в виду 9X_validation под словом "лучший": Если вы говорите 9X_regex о перехвате каждого действительного адреса 9X_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*)

(http://www.ex-parrot.com/~pdw/Mail-RFC822-Address.html) Если 9X_email-validation вы ищете что-то попроще, но с его помощью 9X_form-validation можно будет поймать большинство действительных 9X_validation адресов электронной почты, попробуйте что-нибудь 9X_email-validation вроде:

"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"

РЕДАКТИРОВАТЬ: По ссылке:

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

367
11

  • @RSC, это полное доменное имя ...

Ответ #6

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Пер the W3C HTML5 spec:

^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$

Контекст:

Действительный адрес электронной почты - это строка, которая соответствует 9X_regex продукту ABNF […].

Примечание. Это требование является willful violation из RFC 5322, которое определяет синтаксис для адресов электронной почты, который одновременно является слишком строгим (до символа «@») и слишком расплывчатым (после символа «@» ”Символ) и слишком слабый (позволяющий использовать комментарии, пробелы и строки в кавычках способами, незнакомыми большинству пользователей).

Следующее регулярное выражение, совместимое с JavaScript и Perl, является реализацией приведенного выше определения.

/^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/

318
3

  • @mmmmmm `john.doe @ localhost` является допустимым. Конечно, в реальном приложении (то есть в сообществе) я бы хотел, чтобы вы пре ...

Ответ #7

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

[ОБНОВЛЕНО] Я собрал все, что знаю о проверке 9X_validate адресов электронной почты, здесь: http://isemail.info, который 9X_email-integration теперь не только проверяет, но и диагностирует 9X_regular-expression проблемы с адресами электронной почты. Я 9X_regexp согласен со многими комментариями здесь, что 9X_email-integration проверка - это только часть ответа; см. мое 9X_form-validation эссе на http://isemail.info/about.

is_email() остается, насколько 9X_email мне известно, единственным валидатором, который 9X_mail точно скажет вам, является ли данная строка 9X_validate действительным адресом электронной почты 9X_email-integration или нет. Я загрузил новую версию на http://isemail.info/

Я собрал 9X_regex тестовые примеры от Кэла Хендерсона, Дэйва 9X_email Чайлда, Фила Хаака, Дуга Ловелла, RFC5322 9X_string-parsing и RFC 3696. Всего 275 тестовых адресов. Я 9X_regular-expression провел все эти тесты со всеми бесплатными 9X_regular-expression валидаторами, которые смог найти.

Я постараюсь 9X_regular-expression поддерживать эту страницу в актуальном состоянии 9X_validation по мере того, как люди улучшают свои валидаторы. Спасибо 9X_regular-expression Кэлу, Майклу, Дэйву, Полу и Филу за их помощь 9X_mail и сотрудничество при составлении этих тестов 9X_regular-expression и конструктивную критику my own validator.

Люди должны знать, в 9X_regular-expressions частности, о errata against RFC 3696. Три канонических примера 9X_form-validation на самом деле являются недействительными 9X_mail адресами. Максимальная длина адреса - 254 9X_regular-expressions или 256 символов, не 320.

295
2

  • Очень хорошо. Здесь мы получаем не только красивое эссе, но и тестер валидации, а также библиотеку для з ...

Ответ #8

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Это просто в Perl 5.10 или новее:

/(?(DEFINE)
   (?
(?&mailbox) | (?&group)) (? (?&name_addr) | (?&addr_spec)) (? (?&display_name)? (?&angle_addr)) (? (?&CFWS)? < (?&addr_spec) > (?&CFWS)?) (? (?&display_name) : (?:(?&mailbox_list) | (?&CFWS))? ; (?&CFWS)?) (? (?&phrase)) (? (?&mailbox) (?: , (?&mailbox))*) (? (?&local_part) \@ (?&domain)) (? (?&dot_atom) | (?"ed_string)) (? (?&dot_atom) | (?&domain_literal)) (? (?&CFWS)? \[ (?: (?&FWS)? (?&dcontent))* (?&FWS)? \] (?&CFWS)?) (? (?&dtext) | (?"ed_pair)) (? (?&NO_WS_CTL) | [\x21-\x5a\x5e-\x7e]) (? (?&ALPHA) | (?&DIGIT) | [!#\$%&'*+-/=?^_`{|}~]) (? (?&CFWS)? (?&atext)+ (?&CFWS)?) (? (?&CFWS)? (?&dot_atom_text) (?&CFWS)?) (? (?&atext)+ (?: \. (?&atext)+)*) (? [\x01-\x09\x0b\x0c\x0e-\x7f]) (? \\ (?&text)) (? (?&NO_WS_CTL) | [\x21\x23-\x5b\x5d-\x7e]) (? (?&qtext) | (?"ed_pair)) (? (?&CFWS)? (?&DQUOTE) (?:(?&FWS)? (?&qcontent))* (?&FWS)? (?&DQUOTE) (?&CFWS)?) (? (?&atom) | (?"ed_string)) (? (?&word)+) # Folding white space (? (?: (?&WSP)* (?&CRLF))? (?&WSP)+) (? (?&NO_WS_CTL) | [\x21-\x27\x2a-\x5b\x5d-\x7e]) (? (?&ctext) | (?"ed_pair) | (?&comment)) (? \( (?: (?&FWS)? (?&ccontent))* (?&FWS)? \) ) (? (?: (?&FWS)? (?&comment))* (?: (?:(?&FWS)? (?&comment)) | (?&FWS))) # No whitespace control (? [\x01-\x08\x0b\x0c\x0e-\x1f\x7f]) (? [A-Za-z]) (? [0-9]) (? \x0d \x0a) (? ") (? [\x20\x09]) ) (?&address)/x

9X_email-validation

205
6

  • Я думаю, что только часть части `addrspec` действительно имеет отношение к вопросу. Принятие большего и отправка его через какую-то другую часть системы, которая не готова принимать полные адреса RFC5822, - ...

Ответ #9

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Я использую

^\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$

Какая из них используется в ASP.NET 9X_mail с помощью RegularExpressionValidator.

193
5

  • Бу! Мой (опрометчивый) адрес `! @ Mydomain.net` отклонен.<p><spa ...

Ответ #10

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Не знаю, как лучше, но this one по крайней мере 9X_string-parsing верен, если комментарии к адресам удалены 9X_email и заменены пробелами.

Серьезно. Вы должны 9X_email-integration использовать уже написанную библиотеку для 9X_regex проверки электронных писем. Лучше всего, вероятно, просто 9X_email отправить электронное письмо с подтверждением 9X_regular-expression на этот адрес.

148
3

  • Насколько я знаю, некоторые библиотеки тоже ошибаются. Я ...

Ответ #11

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Быстрый ответ

Используйте следующее регулярное выражение 9X_validation для проверки ввода:

([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\\[\t -~]))+")@[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?(\.[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?)+

Адреса, соответствующие 9X_email-validation этому регулярному выражению:

  • иметь локальную часть (то есть часть перед знаком @), которая строго соответствует RFC 5321/5322,
  • иметь часть домена (т.е. часть после знака @), которая представляет собой имя хоста с как минимум двумя метками, каждая из которых состоит не более чем из 63 символов.

Второе ограничение 9X_email-integration - это ограничение RFC 5321/5322.

Подробный ответ

Использование 9X_email-integration регулярного выражения, распознающего адреса 9X_regexp электронной почты, может быть полезно в 9X_string-parsing различных ситуациях: например, для поиска 9X_mail адресов электронной почты в документе, для 9X_mail проверки ввода данных пользователем или 9X_regex в качестве ограничения целостности в репозитории 9X_email данных.

Следует, однако, отметить, что если 9X_regexp вы хотите узнать, действительно ли адрес 9X_regex относится к существующему почтовому ящику, ничто 9X_regex не заменит отправку сообщения на этот адрес. Если 9X_regular-expressions вы хотите только проверить грамматически 9X_validation правильный адрес, вы можете использовать 9X_email-integration регулярное выражение, но обратите внимание, что 9X_validate ""@[] - это грамматически правильный адрес электронной 9X_mail почты, который определенно не относится 9X_form-validation к существующему почтовому ящику.

Синтаксис 9X_validation адресов электронной почты определен в различных 9X_validation тегах RFCs, в первую очередь в RFC 822 и RFC 5322. RFC 822 9X_regular-expression следует рассматривать как «исходный» стандарт, а 9X_regular-expression RFC 5322 - как последний стандарт. Синтаксис, определенный 9X_email в RFC 822, является наиболее мягким, и последующие 9X_email-validation стандарты все больше и больше ограничивали 9X_mail синтаксис, при этом новые системы или службы 9X_validate должны распознавать устаревший синтаксис, но 9X_form-validation никогда не создавать его.

В этом ответе я 9X_regexp буду использовать термин «адрес электронной 9X_regular-expressions почты» для обозначения addr-spec, как определено 9X_email-integration в RFC (т.е. jdoe@example.org, но не "John Doe" и some-group:jdoe@example.org,mrx@exampel.org;).

Есть одна проблема 9X_string-parsing с преобразованием синтаксиса RFC в регулярные 9X_regexp выражения: синтаксис нестандартный! Это 9X_string-parsing связано с тем, что они допускают необязательные 9X_regex комментарии в адресах электронной почты, которые 9X_regexp могут быть бесконечно вложенными, в то время 9X_mail как бесконечное вложенность не может быть 9X_string-parsing описано регулярным выражением. Чтобы сканировать 9X_email или проверять адреса, содержащие комментарии, вам 9X_validation понадобится синтаксический анализатор или 9X_form-validation более мощные выражения. (Обратите внимание, что 9X_validation такие языки, как Perl, имеют конструкции 9X_validate для описания контекстно-свободных грамматик 9X_email-integration в виде регулярных выражений.) В этом ответе 9X_email-validation я проигнорирую комментарии и буду рассматривать 9X_validation только правильные регулярные выражения.

RFC 9X_regex определяют синтаксис для сообщений электронной 9X_regex почты, а не для адресов электронной почты 9X_email-validation как таковых. Адреса могут появляться в различных 9X_form-validation полях заголовков, и именно здесь они в первую 9X_mail очередь определяются. Когда они появляются 9X_form-validation в полях заголовков, адреса могут содержать 9X_mail (между лексическими токенами) пробелы, комментарии 9X_email и даже разрывы строк. Однако семантически 9X_email-validation это не имеет значения. Удалив этот пробел 9X_regular-expression и т. Д. Из адреса, вы получите семантически 9X_email-integration эквивалентное каноническое представление. Таким образом, каноническое 9X_email-integration представление first. last (comment) @ [3.5.7.9] - first.last@[3.5.7.9].

Для разных целей следует 9X_form-validation использовать разные синтаксисы. Если вы 9X_regex хотите сканировать адреса электронной почты 9X_regular-expressions в (возможно, очень старом) документе, может 9X_validate быть хорошей идеей использовать синтаксис, определенный 9X_regular-expressions в RFC 822. С другой стороны, если вы хотите 9X_email-integration проверить ввод данных пользователем, вы 9X_form-validation можете захотеть использовать синтаксис, как 9X_email-integration определено в RFC 5322, вероятно, принимает 9X_mail только канонические представления. Вы должны 9X_validation решить, какой синтаксис применим к вашему 9X_validate конкретному случаю.

В этом ответе я использую 9X_regex "расширенные" регулярные выражения 9X_validate POSIX, предполагая, что набор символов совместим 9X_form-validation с ASCII.

RFC 822

Я пришел к следующему регулярному 9X_form-validation выражению. Я приглашаю всех попробовать 9X_email и сломать его. Если вы обнаружите ложные 9X_string-parsing срабатывания или ложно отрицательные результаты, опубликуйте 9X_regular-expressions их в комментарии, и я постараюсь исправить 9X_validation это выражение как можно скорее.

([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]))*(\\\r)*")(\.([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]))*(\\\r)*"))*@([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]))*(\\\r)*])(\.([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]))*(\\\r)*]))*

Я считаю, что 9X_regex он полностью соответствует RFC 822, включая 9X_regular-expression errata. Он распознает только адреса электронной 9X_email-integration почты в их канонической форме. Для регулярного 9X_validate выражения, распознающего (сворачивающего) пробелы, см. Вывод 9X_string-parsing ниже.

Вывод показывает, как я пришел к выражению. Я 9X_form-validation перечисляю все соответствующие грамматические 9X_mail правила из RFC в том виде, в котором они 9X_regular-expression появляются, за которым следует соответствующее 9X_form-validation регулярное выражение. Если была опубликована 9X_email-integration ошибка, я даю отдельное выражение для исправленного 9X_regular-expressions грамматического правила (помечено как «erratum») и 9X_regular-expressions использую обновленную версию как часть выражения 9X_mail в последующих регулярных выражениях.

Как 9X_form-validation указано в п. 3.1.4. RFC 822 между лексическими 9X_email-validation токенами может быть вставлен необязательный 9X_regular-expression линейный пробел. Где применимо, я расширил 9X_form-validation выражения, чтобы учесть это правило, и пометил 9X_regular-expressions результат как «opt-lwsp».

CHAR        =  
            =~ .

CTL         =  
            =~ [\x00-\x1F\x7F]

CR          =  
            =~ \r

LF          =  
            =~ \n

SPACE       =  
            =~  

HTAB        =  
            =~ \t

<">         =  
            =~ "

CRLF        =  CR LF
            =~ \r\n

LWSP-char   =  SPACE / HTAB
            =~ [ \t]

linear-white-space =  1*([CRLF] LWSP-char)
                   =~ ((\r\n)?[ \t])+

specials    =  "(" / ")" / "<" / ">" / "@" /  "," / ";" / ":" / "\" / <"> /  "." / "[" / "]"
            =~ [][()<>@,;:\\".]

quoted-pair =  "\" CHAR
            =~ \\.

qtext       =  , "\" & CR, and including linear-white-space>
            =~ [^"\\\r]|((\r\n)?[ \t])+

dtext       =  
            =~ [^][\\\r]|((\r\n)?[ \t])+

quoted-string  =  <"> *(qtext|quoted-pair) <">
               =~ "([^"\\\r]|((\r\n)?[ \t])|\\.)*"
(erratum)      =~ "(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*"

domain-literal =  "[" *(dtext|quoted-pair) "]"
               =~ \[([^][\\\r]|((\r\n)?[ \t])|\\.)*]
(erratum)      =~ \[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*]

atom        =  1*
            =~ [^][()<>@,;:\\". \x00-\x1F\x7F]+

word        =  atom / quoted-string
            =~ [^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*"

domain-ref  =  atom

sub-domain  =  domain-ref / domain-literal
            =~ [^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*]

local-part  =  word *("." word)
            =~ ([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*")(\.([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*"))*
(opt-lwsp)  =~ ([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*")(((\r\n)?[ \t])*\.((\r\n)?[ \t])*([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*"))*

domain      =  sub-domain *("." sub-domain)
            =~ ([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*])(\.([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*]))*
(opt-lwsp)  =~ ([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*])(((\r\n)?[ \t])*\.((\r\n)?[ \t])*([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*]))*

addr-spec   =  local-part "@" domain
            =~ ([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*")(\.([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*"))*@([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*])(\.([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*]))*
(opt-lwsp)  =~ ([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*")((\r\n)?[ \t])*(\.((\r\n)?[ \t])*([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*")((\r\n)?[ \t])*)*@((\r\n)?[ \t])*([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*])(((\r\n)?[ \t])*\.((\r\n)?[ \t])*([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*]))*
(canonical) =~ ([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]))*(\\\r)*")(\.([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]))*(\\\r)*"))*@([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]))*(\\\r)*])(\.([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]))*(\\\r)*]))*

RFC 5322

Я пришел к следующему 9X_form-validation регулярному выражению. Я приглашаю всех 9X_regular-expressions попробовать и сломать его. Если вы обнаружите 9X_validation ложные срабатывания или ложные отрицания, опубликуйте 9X_form-validation их в комментарии, и я постараюсь исправить 9X_string-parsing это выражение как можно скорее.

([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\\[\t -~]))+")@([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|\[[\t -Z^-~]*])

Я считаю, что 9X_email-validation он полностью соответствует RFC 5322, включая 9X_validate errata. Он распознает только адреса электронной 9X_mail почты в их канонической форме. Для регулярного 9X_email-validation выражения, распознающего (сворачивающего) пробелы, см. Вывод 9X_regexp ниже.

Вывод показывает, как я пришел к выражению. Я 9X_email перечисляю все соответствующие грамматические 9X_regular-expression правила из RFC в том виде, в котором они 9X_regular-expression появляются, за которым следует соответствующее 9X_string-parsing регулярное выражение. Для правил, которые 9X_regex включают семантически нерелевантные (сворачивающиеся) пробелы, я 9X_mail даю отдельное регулярное выражение с пометкой 9X_validation «(нормализовано)», которое не принимает 9X_regular-expressions эти пробелы.

Я проигнорировал все правила 9X_email-validation "obs-" из RFC. Это означает, что 9X_string-parsing регулярные выражения соответствуют только 9X_regular-expression адресам электронной почты, которые строго 9X_validate соответствуют RFC 5322. Если вам нужно сопоставить 9X_email-integration «старые» адреса (как это делает более свободная 9X_string-parsing грамматика, включая правила «obs-»), вы 9X_regex можете использовать одно из регулярных выражений 9X_validate RFC 822 из предыдущего абзаца.

VCHAR           =   %x21-7E
                =~  [!-~]

ALPHA           =   %x41-5A / %x61-7A
                =~  [A-Za-z]

DIGIT           =   %x30-39
                =~  [0-9]

HTAB            =   %x09
                =~  \t

CR              =   %x0D
                =~  \r

LF              =   %x0A
                =~  \n

SP              =   %x20
                =~  

DQUOTE          =   %x22
                =~  "

CRLF            =   CR LF
                =~  \r\n

WSP             =   SP / HTAB
                =~  [\t ]

quoted-pair     =   "\" (VCHAR / WSP)
                =~  \\[\t -~]

FWS             =   ([*WSP CRLF] 1*WSP)
                =~  ([\t ]*\r\n)?[\t ]+

ctext           =   %d33-39 / %d42-91 / %d93-126
                =~  []!-'*-[^-~]

("comment" is left out in the regex)
ccontent        =   ctext / quoted-pair / comment
                =~  []!-'*-[^-~]|(\\[\t -~])

(not regular)
comment         =   "(" *([FWS] ccontent) [FWS] ")"

(is equivalent to FWS when leaving out comments)
CFWS            =   (1*([FWS] comment) [FWS]) / FWS
                =~  ([\t ]*\r\n)?[\t ]+

atext           =   ALPHA / DIGIT / "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "/" / "=" / "?" / "^" / "_" / "`" / "{" / "|" / "}" / "~"
                =~  [-!#-'*+/-9=?A-Z^-~]

dot-atom-text   =   1*atext *("." 1*atext)
                =~  [-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*

dot-atom        =   [CFWS] dot-atom-text [CFWS]
                =~  (([\t ]*\r\n)?[\t ]+)?[-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*(([\t ]*\r\n)?[\t ]+)?
(normalized)    =~  [-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*

qtext           =   %d33 / %d35-91 / %d93-126
                =~  []!#-[^-~]

qcontent        =   qtext / quoted-pair
                =~  []!#-[^-~]|(\\[\t -~])

(erratum)
quoted-string   =   [CFWS] DQUOTE ((1*([FWS] qcontent) [FWS]) / FWS) DQUOTE [CFWS]
                =~  (([\t ]*\r\n)?[\t ]+)?"(((([\t ]*\r\n)?[\t ]+)?([]!#-[^-~]|(\\[\t -~])))+(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?)"(([\t ]*\r\n)?[\t ]+)?
(normalized)    =~  "([]!#-[^-~ \t]|(\\[\t -~]))+"

dtext           =   %d33-90 / %d94-126
                =~  [!-Z^-~]

domain-literal  =   [CFWS] "[" *([FWS] dtext) [FWS] "]" [CFWS]
                =~  (([\t ]*\r\n)?[\t ]+)?\[((([\t ]*\r\n)?[\t ]+)?[!-Z^-~])*(([\t ]*\r\n)?[\t ]+)?](([\t ]*\r\n)?[\t ]+)?
(normalized)    =~  \[[\t -Z^-~]*]

local-part      =   dot-atom / quoted-string
                =~  (([\t ]*\r\n)?[\t ]+)?[-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?"(((([\t ]*\r\n)?[\t ]+)?([]!#-[^-~]|(\\[\t -~])))+(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?)"(([\t ]*\r\n)?[\t ]+)?
(normalized)    =~  [-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\\[\t -~]))+"

domain          =   dot-atom / domain-literal
                =~  (([\t ]*\r\n)?[\t ]+)?[-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?\[((([\t ]*\r\n)?[\t ]+)?[!-Z^-~])*(([\t ]*\r\n)?[\t ]+)?](([\t ]*\r\n)?[\t ]+)?
(normalized)    =~  [-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|\[[\t -Z^-~]*]

addr-spec       =   local-part "@" domain
                =~  ((([\t ]*\r\n)?[\t ]+)?[-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?"(((([\t ]*\r\n)?[\t ]+)?([]!#-[^-~]|(\\[\t -~])))+(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?)"(([\t ]*\r\n)?[\t ]+)?)@((([\t ]*\r\n)?[\t ]+)?[-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?\[((([\t ]*\r\n)?[\t ]+)?[!-Z^-~])*(([\t ]*\r\n)?[\t ]+)?](([\t ]*\r\n)?[\t ]+)?)
(normalized)    =~  ([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\\[\t -~]))+")@([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|\[[\t -Z^-~]*])

Обратите внимание, что 9X_regular-expressions некоторые источники (в частности, W3C) утверждают, что 9X_form-validation RFC 5322 слишком строг в отношении локальной 9X_email-integration части (т.е. части перед знаком @). Это потому, что 9X_string-parsing «..», «а..б» и «а». не действительных точечных 9X_validate атомов, хотя они могут использоваться в 9X_regular-expressions качестве имен почтовых ящиков. Однако RFC 9X_email допускает такие локальные части, за исключением того, что 9X_mail они должны быть указаны в кавычках. Поэтому 9X_form-validation вместо a..b@example.net вы должны написать "a..b"@example.net, что семантически 9X_regex эквивалентно.

Дополнительные ограничения

SMTP (как определено в RFC 5321) дополнительно 9X_regular-expressions ограничивает набор действительных адресов 9X_validation электронной почты (или фактически: имена 9X_regex почтовых ящиков). Кажется разумным ввести 9X_email-integration эту более строгую грамматику, чтобы сопоставленный 9X_email-integration адрес электронной почты действительно можно 9X_email-integration было использовать для отправки электронной 9X_regexp почты.

RFC 5321 в основном оставляет в покое 9X_email-validation «локальную» часть (то есть часть перед знаком 9X_regexp @), но строже относится к части домена (то 9X_validate есть части после знака @). Он позволяет 9X_validation использовать только имена хостов вместо 9X_form-validation точечных атомов и адресные литералы вместо 9X_form-validation доменных литералов.

Грамматика, представленная 9X_form-validation в RFC 5321, слишком мягка, когда речь идет 9X_mail как об именах хостов, так и об IP-адресах. Я 9X_email взял на себя смелость «исправить» рассматриваемые 9X_regex правила, используя this draft и RFC 1034 в качестве рекомендаций. Вот 9X_email-integration получившееся регулярное выражение.

([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\\[\t -~]))+")@([0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?(\.[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?)*|\[((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}|IPv6:((((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){6}|::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){5}|[0-9A-Fa-f]{0,4}::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){4}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):)?(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){3}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,2}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){2}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,3}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,4}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,5}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,6}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)|(?!IPv6:)[0-9A-Za-z-]*[0-9A-Za-z]:[!-Z^-~]+)])

Обратите 9X_regexp внимание, что в зависимости от варианта 9X_email-integration использования, возможно, вы не захотите 9X_email разрешить использование "General-address-literal" в 9X_string-parsing своем регулярном выражении. Также обратите 9X_regular-expressions внимание, что я использовал отрицательный 9X_form-validation просмотр вперед (?!IPv6:) в последнем регулярном 9X_regex выражении, чтобы предотвратить совпадение 9X_regex части «General-address-literal» с искаженными 9X_regular-expression адресами IPv6. Некоторые процессоры регулярных 9X_mail выражений не поддерживают отрицательный 9X_email просмотр вперед. Удалите подстроку |(?!IPv6:)[0-9A-Za-z-]*[0-9A-Za-z]:[!-Z^-~]+ из регулярного 9X_validate выражения, если вы хотите убрать целую часть 9X_validate «General-address-literal».

Вот вывод:

Let-dig         =   ALPHA / DIGIT
                =~  [0-9A-Za-z]

Ldh-str         =   *( ALPHA / DIGIT / "-" ) Let-dig
                =~  [0-9A-Za-z-]*[0-9A-Za-z]

(regex is updated to make sure sub-domains are max. 63 charactes long - RFC 1034 section 3.5)
sub-domain      =   Let-dig [Ldh-str]
                =~  [0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?

Domain          =   sub-domain *("." sub-domain)
                =~  [0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?(\.[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?)*

Snum            =   1*3DIGIT
                =~  [0-9]{1,3}

(suggested replacement for "Snum")
ip4-octet       =   DIGIT / %x31-39 DIGIT / "1" 2DIGIT / "2" %x30-34 DIGIT / "25" %x30-35
                =~  25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9]

IPv4-address-literal    =   Snum 3("."  Snum)
                        =~  [0-9]{1,3}(\.[0-9]{1,3}){3}

(suggested replacement for "IPv4-address-literal")
ip4-address     =   ip4-octet 3("." ip4-octet)
                =~  (25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}

(suggested replacement for "IPv6-hex")
ip6-h16         =   "0" / ( (%x49-57 / %x65-70 /%x97-102) 0*3(%x48-57 / %x65-70 /%x97-102) )
                =~  0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}

(not from RFC)
ls32            =   ip6-h16 ":" ip6-h16 / ip4-address
                =~  (0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}

(suggested replacement of "IPv6-addr")
ip6-address     =                                      6(ip6-h16 ":") ls32
                    /                             "::" 5(ip6-h16 ":") ls32
                    / [                 ip6-h16 ] "::" 4(ip6-h16 ":") ls32
                    / [ *1(ip6-h16 ":") ip6-h16 ] "::" 3(ip6-h16 ":") ls32
                    / [ *2(ip6-h16 ":") ip6-h16 ] "::" 2(ip6-h16 ":") ls32
                    / [ *3(ip6-h16 ":") ip6-h16 ] "::"   ip6-h16 ":"  ls32
                    / [ *4(ip6-h16 ":") ip6-h16 ] "::"                ls32
                    / [ *5(ip6-h16 ":") ip6-h16 ] "::"   ip6-h16
                    / [ *6(ip6-h16 ":") ip6-h16 ] "::"
                =~  (((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){6}|::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){5}|[0-9A-Fa-f]{0,4}::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){4}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):)?(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){3}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,2}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){2}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,3}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,4}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,5}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,6}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::

IPv6-address-literal    =   "IPv6:" ip6-address
                        =~  IPv6:((((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){6}|::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){5}|[0-9A-Fa-f]{0,4}::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){4}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):)?(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){3}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,2}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){2}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,3}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,4}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,5}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,6}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)

Standardized-tag        =   Ldh-str
                        =~  [0-9A-Za-z-]*[0-9A-Za-z]

dcontent        =   %d33-90 / %d94-126
                =~  [!-Z^-~]

General-address-literal =   Standardized-tag ":" 1*dcontent
                        =~  [0-9A-Za-z-]*[0-9A-Za-z]:[!-Z^-~]+

address-literal =   "[" ( IPv4-address-literal / IPv6-address-literal / General-address-literal ) "]"
                =~  \[((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}|IPv6:((((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){6}|::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){5}|[0-9A-Fa-f]{0,4}::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){4}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):)?(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){3}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,2}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){2}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,3}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,4}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,5}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,6}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)|(?!IPv6:)[0-9A-Za-z-]*[0-9A-Za-z]:[!-Z^-~]+)]

Mailbox         =   Local-part "@" ( Domain / address-literal )
                =~  ([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\\[\t -~]))+")@([0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?(\.[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?)*|\[((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}|IPv6:((((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){6}|::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){5}|[0-9A-Fa-f]{0,4}::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){4}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):)?(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){3}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,2}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){2}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,3}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,4}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,5}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,6}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)|(?!IPv6:)[0-9A-Za-z-]*[0-9A-Za-z]:[!-Z^-~]+)])

Проверка пользовательского ввода

Типичным 9X_regular-expression вариантом использования является проверка 9X_email-integration ввода данных пользователем, например, в 9X_string-parsing html-форме. В этом случае обычно разумно 9X_form-validation исключить адресные литералы и потребовать 9X_regex как минимум две метки в имени хоста. Взяв 9X_regular-expression за основу улучшенное регулярное выражение 9X_regular-expression RFC 5321 из предыдущего раздела, результирующее 9X_regular-expressions выражение будет выглядеть следующим образом:

([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\\[\t -~]))+")@[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?(\.[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?)+

Я 9X_validate не рекомендую дополнительно ограничивать 9X_mail локальную часть, например исключая строки 9X_regular-expression в кавычках, поскольку мы не знаем, какие 9X_email-integration имена почтовых ящиков разрешают некоторые 9X_validate хосты (например, "a..b"@example.net или даже "a b"@example.net).

Я также не 9X_email-validation рекомендую явно проверять список буквальных 9X_email-validation доменов верхнего уровня или даже вводить 9X_regexp ограничения по длине (помните, как ".museum" аннулировал 9X_form-validation [a-z]{2,4}), но если вы должны:

([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\\[\t -~]))+")@([0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?\.)*(net|org|com|info| и т. д. )

Обязательно обновляйте 9X_string-parsing свое регулярное выражение, если вы решите 9X_regexp пойти по пути явной проверки домена верхнего 9X_regular-expressions уровня.

Дополнительные соображения

Если в доменной части (после символа 9X_string-parsing @) принимаются только имена хостов, регулярные 9X_email выражения выше принимают только метки, содержащие 9X_string-parsing не более 63 символов, как и должно быть. Однако 9X_validation они не предписывают тот факт, что полное 9X_email-integration имя хоста должно состоять не более чем из 9X_regular-expression 253 символов (включая точки). Хотя это ограничение, строго 9X_mail говоря, по-прежнему является обычным, создать 9X_validate регулярное выражение, включающее это правило, невозможно.

Еще 9X_regex одно соображение, особенно при использовании 9X_mail регулярных выражений для проверки ввода, - это 9X_validation обратная связь с пользователем. Если пользователь 9X_email-integration вводит неправильный адрес, было бы неплохо 9X_regular-expressions дать немного больше отзывов, чем простой 9X_email «синтаксически неправильный адрес». С "ванильными" регулярными 9X_regular-expressions выражениями это невозможно.

Эти два момента 9X_regular-expression можно решить, проанализировав адрес. Ограничение 9X_string-parsing дополнительной длины для имен хостов в некоторых 9X_regex случаях также может быть устранено с помощью 9X_validation дополнительного регулярного выражения, которое 9X_email-integration проверяет его и сопоставляет адрес с обоими 9X_regex выражениями.

Ни одно из регулярных выражений 9X_regular-expression в этом ответе не оптимизировано для повышения 9X_form-validation производительности. Если производительность 9X_form-validation является проблемой, вы должны посмотреть, можно 9X_regular-expression ли (и как) оптимизировать регулярное выражение 9X_regex по вашему выбору.

129
1

  • RFC [6532] (https://tools.ietf.org/html/rfc6532) обновляет [5322] (https://tools.ietf.org/html/rfc5322), чтобы разрешить и включить полный, чистый UTF-8. Дополн ...

Ответ #12

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Адреса электронной почты, которые я хочу 9X_regex проверить, будут использоваться веб-приложением 9X_regexp ASP.NET, использующим пространство имен 9X_regexp System.Net.Mail для отправки электронных писем списку людей.

Итак, вместо 9X_regular-expressions того, чтобы использовать какое-то очень 9X_email сложное регулярное выражение, я просто пытаюсь 9X_email создать экземпляр MailAddress из адреса. Конструктор 9X_regexp MailAddress выдаст исключение, если адрес сформирован 9X_validate неправильно. Таким образом, я знаю, что, по 9X_form-validation крайней мере, смогу выпустить электронное 9X_validation письмо за дверь. Конечно, это проверка на 9X_regular-expression стороне сервера, но как минимум она вам 9X_validate все равно нужна.

protected void emailValidator_ServerValidate(object source, ServerValidateEventArgs args)
{
    try
    {
        var a = new MailAddress(txtEmail.Text);
    }
    catch (Exception ex)
    {
        args.IsValid = false;
        emailValidator.ErrorMessage = "email: " + ex.Message;
    }
}

115
2

  • Просто примечание: класс MailAddress не соответствует RFC5322, если вы просто хотите использовать его для проверки (а не ...

Ответ #13

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

В Интернете есть множество примеров этого 9X_regular-expressions (и я думаю, что даже тот, который полностью 9X_regexp проверяет RFC, но он состоит из десятков 9X_email-validation и сотен строк, если память не изменяет).

Люди 9X_regular-expression склонны увлекаться проверкой подобных вещей. Почему 9X_email бы просто не проверить, что он имеет @ и 9X_form-validation хотя бы один . и соответствует какой-то простой 9X_validate минимальной длине? Просто ввести поддельный 9X_validate адрес электронной почты и все равно сопоставить 9X_string-parsing любое действительное регулярное выражение. Я 9X_email-integration предполагаю, что ложные срабатывания лучше 9X_form-validation ложноотрицательных.

76
3

  • А. не требуется. TLD может иметь адреса электронной почты или IPv6-адрес.< ...

Ответ #14

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Принимая решение о том, какие символы можно 9X_validate использовать, помните о своих друзьях с 9X_regular-expressions апострофом и дефисом. Я не контролирую тот 9X_regular-expression факт, что моя компания генерирует мой адрес 9X_validate электронной почты, используя мое имя из 9X_validate системы управления персоналом. Это включает 9X_regexp апостроф в моей фамилии. Я не могу сказать 9X_email вам, сколько раз мне блокировали взаимодействие 9X_regular-expressions с веб-сайтом из-за того, что мой адрес электронной 9X_mail почты «недействителен».

66
2

  • да. Меня особенно бесит то, что программисты от ...

Ответ #15

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Это регулярное выражение из библиотеки Perl 9X_string-parsing Email::Valid. Я считаю, что он самый точный и соответствует 9X_email всем 822. И он основан на регулярном выражении 9X_regex из книги О'Рейли:

Регулярное выражение, построенное 9X_validate на примере Джеффри Фридла в Освоение регулярных выражений (http://www.ora.com/catalog/regexp/).

$RFC822PAT = <<'EOF';
[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\
xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xf
f\n\015()]*)*\)[\040\t]*)*(?:(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\x
ff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"[^\\\x80-\xff\n\015
"]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015"]*)*")[\040\t]*(?:\([^\\\x80-\
xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80
-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*
)*(?:\.[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\
\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\
x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x8
0-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"[^\\\x80-\xff\n
\015"]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015"]*)*")[\040\t]*(?:\([^\\\x
80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^
\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040
\t]*)*)*@[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([
^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\
\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\
x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-
\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()
]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\
x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\04
0\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\
n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\
015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?!
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\
]]|\\[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\
x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\01
5()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*)*|(?:[^(\040)<>@,;:".
\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]
)|"[^\\\x80-\xff\n\015"]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015"]*)*")[^
()<>@,;:".\\\[\]\x80-\xff\000-\010\012-\037]*(?:(?:\([^\\\x80-\xff\n\0
15()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][
^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)|"[^\\\x80-\xff\
n\015"]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015"]*)*")[^()<>@,;:".\\\[\]\
x80-\xff\000-\010\012-\037]*)*<[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?
:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-
\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:@[\040\t]*
(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015
()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()
]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\0
40)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\
[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\
xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*
)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:\([^\\\x80
-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x
80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t
]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\
\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])
*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x
80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80
-\xff\n\015()]*)*\)[\040\t]*)*)*(?:,[\040\t]*(?:\([^\\\x80-\xff\n\015(
)]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\
\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*@[\040\t
]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\0
15()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015
()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(
\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|
\\[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80
-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()
]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:\([^\\\x
80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^
\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040
\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".
\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff
])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\
\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x
80-\xff\n\015()]*)*\)[\040\t]*)*)*)*:[\040\t]*(?:\([^\\\x80-\xff\n\015
()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\
\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*)?(?:[^
(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-
\037\x80-\xff])|"[^\\\x80-\xff\n\015"]*(?:\\[^\x80-\xff][^\\\x80-\xff\
n\015"]*)*")[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|
\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))
[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:\([^\\\x80-\xff
\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\x
ff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(
?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\
000-\037\x80-\xff])|"[^\\\x80-\xff\n\015"]*(?:\\[^\x80-\xff][^\\\x80-\
xff\n\015"]*)*")[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\x
ff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)
*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*)*@[\040\t]*(?:\([^\\\x80-\x
ff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-
\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)
*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\
]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\]
)[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-
\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\x
ff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(
?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80
-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<
>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x8
0-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(?:
\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]
*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)
*\)[\040\t]*)*)*>)
EOF

63
1

  • O_O вам также нужно быть мастером регулярных выражений, чтоб ...

Ответ #16

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Поскольку вы пишете на PHP, я бы посоветовал 9X_email-validation вам использовать встроенную проверку PHP 9X_regular-expression для электронных писем.

filter_var($value, FILTER_VALIDATE_EMAIL)

Если вы используете 9X_email версию PHP ниже 5.3.6, помните об этой проблеме: Bug #53091: Crashes when I try to filter a text of > 2264 characters

Если 9X_form-validation вам нужна дополнительная информация о том, как 9X_string-parsing работает эта встроенная проверка, см. здесь: Does PHP's filter_var FILTER_VALIDATE_EMAIL actually work?

46
0

Ответ #17

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Cal Henderson (Flickr) написал статью под названием Parsing Email Addresses in PHP, в 9X_email-integration которой показано, как правильно выполнить 9X_email-integration синтаксический анализ адресов электронной 9X_regex почты в соответствии с RFC (2) 822.

Вы также 9X_mail можете получить исходный код на PHP, Python 9X_mail и Ruby, то есть на Creative Commons licensed.

43
1

  • @dsdsdsdsd Поскольку `a @ b` допустимо ... в этом случае` b ...

Ответ #18

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Я никогда не утруждаю себя созданием собственного 9X_validation регулярного выражения, потому что есть вероятность, что 9X_regex кто-то уже придумал лучшую версию. Я всегда 9X_validate использую regexlib, чтобы найти то, что мне нравится.

41
1

  • Это было помечено из-за длины и ...

Ответ #19

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Одно простое регулярное выражение, которое, по 9X_regex крайней мере, не отклоняет действующий адрес 9X_string-parsing электронной почты, будет проверять что-то, за 9X_string-parsing которым следует знак @, а затем что-то, за 9X_form-validation которым следует точка и как минимум 2 что-то. Он 9X_email-validation ничего не отклонит, но после просмотра спецификации 9X_regular-expressions я не могу найти ни одного действительного 9X_email-validation и отклоненного электронного письма.

email 9X_email-integration = ~ /.+@[^@]+\.[^@]{2,}$/

40
4

  • Верно. Я не пытаюсь отклонить все недействительные, просто ...

Ответ #20

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Нет ни одного действительно пригодного для 9X_regex использования. Некоторые вопросы я обсуждаю 9X_email-integration в моем answer to Is there a PHP library for email address validation?, это также обсуждается в Is regular expression recognition of an email address hard?.

Короче 9X_email-integration говоря, не ожидайте, что одно пригодное 9X_mail для использования регулярное выражение выполнит 9X_mail правильную работу. И лучшее регулярное выражение 9X_regular-expressions будет проверять синтаксис, а не действительность 9X_email электронного письма (jhohn@example.com правильный, но он, вероятно, отскочит 9X_validation ...).

37
0

Ответ #21

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Вы можете использовать тот, который используется 9X_regular-expressions плагином jQuery Validation:

/^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?$/i

29
0

Ответ #22

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Не говоря уже о том, что нелатинские (китайский, арабский, греческий, иврит, кириллица 9X_string-parsing и т. д.) доменные имена должны быть разрешены 9X_regexp в near future. Каждый должен изменить используемое 9X_regex регулярное выражение электронной почты, потому 9X_regexp что эти символы, безусловно, не будут охватываться 9X_validate ни [a-z]/i, ни \w. Все они потерпят неудачу.

В конце 9X_email-validation концов, лучший способ проверить адрес электронной 9X_validate почты - это фактически отправить электронное письмо 9X_mail на указанный адрес для проверки адреса. Если 9X_validation адрес электронной почты является частью 9X_validate аутентификации пользователя (регистрация 9X_regular-expression / вход / и т. Д.), То вы можете идеально 9X_email-validation совместить его с системой активации пользователя. Т.е. отправить 9X_email электронное письмо со ссылкой с уникальным 9X_email-validation ключом активации на указанный адрес электронной 9X_validation почты и разрешить вход только в том случае, если 9X_mail пользователь активировал вновь созданную 9X_email-integration учетную запись, используя ссылку в электронном 9X_regex письме.

Если целью регулярного выражения 9X_email-integration является просто быстрое информирование пользователя 9X_form-validation в пользовательском интерфейсе о том, что 9X_form-validation указанный адрес электронной почты не выглядит 9X_validate в правильном формате, лучше всего проверить, соответствует 9X_regular-expression ли он в основном следующему регулярному 9X_validate выражению:

^([^.@]+)(\.[^.@]+)*@([^.@]+\.)+([^.@]+)$

Все просто. Зачем вам нужны символы, используемые 9X_validation в имени и домене? Ответственность за ввод 9X_validation действующего адреса электронной почты лежит 9X_regular-expression на клиенте, а не на сервере. Даже когда 9X_email клиент вводит синтаксически действительный адрес электронной 9X_regular-expression почты, например aa@bb.cc, это не гарантирует, что 9X_validate это действительный адрес электронной почты. Ни 9X_regex одно регулярное выражение не может покрыть 9X_email-integration это.

27
1

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

Ответ #23

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Для наиболее полной оценки лучшего регулярного 9X_regex выражения для проверки адреса электронной 9X_validation почты перейдите по этой ссылке; "Comparing E-mail Address Validating Regular Expressions"

Вот 9X_regular-expressions текущее верхнее выражение для справки:

/^([\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+\.)*[\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+@((((([a-z0-9]{1}[a-z0-9\-]{0,62}[a-z0-9]{1})|[a-z])\.)+[a-z]{2,6})|(\d{1,3}\.){3}\d{1,3}(\:\d{1,5})?)$/i

26
0

Ответ #24

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

HTML5 spec suggests простое регулярное выражение для проверки 9X_string-parsing адресов электронной почты:

/^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/

Это намеренно 9X_email-integration не соответствует RFC 5322.

Примечание. Это требование является 9X_validation willful violation из RFC 5322, которое определяет синтаксис для адресов 9X_regular-expression электронной почты, который одновременно 9X_string-parsing является слишком строгим (до символа @), слишком 9X_string-parsing расплывчатым ( после символа @) и слишком 9X_string-parsing нестрогие (разрешающие комментарии, пробельные 9X_validate символы и строки в кавычках в манерах, незнакомых 9X_validate большинству пользователей), чтобы иметь 9X_string-parsing здесь практическое применение.

Общая длина 9X_regex также может быть ограничена 254 символами 9X_email-integration на RFC 3696 errata 1690.

21
2

  • Это ТАК не лучший ответ! Этот шаблон соответствует этому полностью недопустимому а ...

Ответ #25

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Для наглядной демонстрации следующий монстр 9X_email-validation довольно хорош, но он по-прежнему не распознает 9X_email правильно все синтаксически допустимые адреса 9X_regular-expression электронной почты: он распознает вложенные 9X_validate комментарии глубиной до четырех уровней.

Это 9X_regular-expression задание для синтаксического анализатора, но 9X_regular-expression даже если адрес синтаксически действителен, он 9X_regular-expression все равно не может быть доставлен. Иногда 9X_regex приходится прибегать к деревенскому методу 9X_regular-expressions «Эй, вы все, смотри, э-э-нас!»

// derivative of work with the following copyright and license:
// Copyright (c) 2004 Casey West.  All rights reserved.
// This module is free software; you can redistribute it and/or
// modify it under the same terms as Perl itself.

// see http://search.cpan.org/~cwest/Email-Address-1.80/

private static string gibberish = @"
(?-xism:(?:(?-xism:(?-xism:(?-xism:(?-xism:(?-xism:(?-xism:\
s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^
\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))
|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+
|\s+)*[^\x00-\x1F\x7F()<>\[\]:;@\,.\s]+(?-xism:(?-xism:\
s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^
\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))
|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+
|\s+)*)|(?-xism:(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(
?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?
:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x
0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*(?-xism:(?-xism:[
^\\])|(?-xism:\\(?-xism:[^\x0A\x0D])))+(?-xism:(?-xi
sm:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xis
m:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\
]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\
s*)+|\s+)*))+)?(?-xism:(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?
-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:
\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[
^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*<(?-xism:(?-xi
sm:(?-xism:(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^(
)\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(
?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))
|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*(?-xism:[^\x00-\x1F\x7F()<
>\[\]:;@\,.\s]+(?:\.[^\x00-\x1F\x7F()<>\[\]:;@\,.\s]
+)*)(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))
|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:
(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s
*\)\s*))+)*\s*\)\s*)+|\s+)*)|(?-xism:(?-xism:(?-xism:\s*\((?
:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x
0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xi
sm:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*
(?-xism:(?-xism:[^\\])|(?-xism:\\(?-xism:[^\x0A\x0D]
)))+(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\
]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-x
ism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+
)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*))\@(?-xism:(?-xism:(?-xism:(
?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?
-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^
()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s
*\)\s*)+|\s+)*(?-xism:[^\x00-\x1F\x7F()<>\[\]:;@\,.\s]+(
?:\.[^\x00-\x1F\x7F()<>\[\]:;@\,.\s]+)*)(?-xism:(?-xism:
\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[
^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+)
)|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)
+|\s+)*)|(?-xism:(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:
(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((
?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\
x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*\[(?:\s*(?-xism:(?-x
ism:[^\[\]\\])|(?-xism:\\(?-xism:[^\x0A\x0D])))+)*\s*\](?-xi
sm:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:
\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(
?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+
)*\s*\)\s*)+|\s+)*)))>(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-
xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\
s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^
\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*))|(?-xism:(?-x
ism:(?-xism:(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^
()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*
(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D])
)|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*(?-xism:[^\x00-\x1F\x7F()
<>\[\]:;@\,.\s]+(?:\.[^\x00-\x1F\x7F()<>\[\]:;@\,.\s
]+)*)(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+)
)|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism
:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\
s*\)\s*))+)*\s*\)\s*)+|\s+)*)|(?-xism:(?-xism:(?-xism:\s*\((
?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\
x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-x
ism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)
*(?-xism:(?-xism:[^\\])|(?-xism:\\(?-xism:[^\x0A\x0D
])))+(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\
\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-
xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)
+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*))\@(?-xism:(?-xism:(?-xism:
(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(
?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[
^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\
s*\)\s*)+|\s+)*(?-xism:[^\x00-\x1F\x7F()<>\[\]:;@\,.\s]+
(?:\.[^\x00-\x1F\x7F()<>\[\]:;@\,.\s]+)*)(?-xism:(?-xism
:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:
[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+
))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*
)+|\s+)*)|(?-xism:(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism
:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\(
(?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A
\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*\[(?:\s*(?-xism:(?-
xism:[^\[\]\\])|(?-xism:\\(?-xism:[^\x0A\x0D])))+)*\s*\](?-x
ism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism
:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:
(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))
+)*\s*\)\s*)+|\s+)*))))(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?
>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:
\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0
D]))|)+)*\s*\)\s*))+)*\s*\)\s*)*)"
  .Replace("", "\"")
  .Replace("\t", "")
  .Replace(" ", "")
  .Replace("\r", "")
  .Replace("\n", "");

private static Regex mailbox =
  new Regex(gibberish, RegexOptions.ExplicitCapture);

16
0

Ответ #26

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Согласно официальному стандарту RFC 2822 допустимое 9X_regex регулярное выражение электронной почты:

(?:[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])+)\])

Если 9X_validate вы хотите использовать его на Java, это 9X_email-validation действительно очень просто:

import java.util.regex.*;

class regexSample 
{
   public static void main(String args[]) 
   {
      //Input the string for validation
      String email = "xyz@hotmail.com";

      //Set the email pattern string
      Pattern p = Pattern.compile(" (?:[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])+)\\]");

      //Match the given string with the pattern
      Matcher m = p.matcher(email);

      //Check whether match is found 
      boolean matchFound = m.matches();

      if (matchFound)
        System.out.println("Valid Email Id.");
      else
        System.out.println("Invalid Email Id.");
   }
}

12
1

  • Ваше регулярное выражение не включает первую заглавную букву, например **Leonardo.davinci@gmail.com**, что может раздражать некоторых пользователей. Используйте вместо этого: `` ( ...

Ответ #27

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Стандарт RFC 5322:

Разрешает локальную часть 9X_regular-expression точки-атома, локальную часть строки в кавычках, устаревшую 9X_email (смешанную точку-атом и строку в кавычках) локальную 9X_validate часть, домен доменного имени, (IPv4, IPv6 9X_email-integration и IPv4-сопоставленный адрес IPv6) домен 9X_mail буквальный домен и (вложенный) CFWS.

'/^(?!(?>(?1)"?(?>\\\[ -~]|[^"])"?(?1)){255,})(?!(?>(?1)"?(?>\\\[ -~]|[^"])"?(?1)){65,}@)((?>(?>(?>((?>(?>(?>\x0D\x0A)?[\t ])+|(?>[\t ]*\x0D\x0A)?[\t ]+)?)(\((?>(?2)(?>[\x01-\x08\x0B\x0C\x0E-\'*-\[\]-\x7F]|\\\[\x00-\x7F]|(?3)))*(?2)\)))+(?2))|(?2))?)([!#-\'*+\/-9=?^-~-]+|"(?>(?2)(?>[\x01-\x08\x0B\x0C\x0E-!#-\[\]-\x7F]|\\\[\x00-\x7F]))*(?2)")(?>(?1)\.(?1)(?4))*(?1)@(?!(?1)[a-z0-9-]{64,})(?1)(?>([a-z0-9](?>[a-z0-9-]*[a-z0-9])?)(?>(?1)\.(?!(?1)[a-z0-9-]{64,})(?1)(?5)){0,126}|\[(?:(?>IPv6:(?>([a-f0-9]{1,4})(?>:(?6)){7}|(?!(?:.*[a-f0-9][:\]]){8,})((?6)(?>:(?6)){0,6})?::(?7)?))|(?>(?>IPv6:(?>(?6)(?>:(?6)){5}:|(?!(?:.*[a-f0-9]:){6,})(?8)?::(?>((?6)(?>:(?6)){0,4}):)?))?(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(?>\.(?9)){3}))\])(?1)$/isD'

Стандарт 9X_regexp RFC 5321:

Разрешает локальную часть точечного 9X_email атома, локальную часть строки в кавычках, домен 9X_validate доменного имени и (IPv4, IPv6 и IPv4-сопоставленный 9X_regexp адрес IPv6) домен литерала.

'/^(?!(?>"?(?>\\\[ -~]|[^"])"?){255,})(?!"?(?>\\\[ -~]|[^"]){65,}"?@)(?>([!#-\'*+\/-9=?^-~-]+)(?>\.(?1))*|"(?>[ !#-\[\]-~]|\\\[ -~])*")@(?!.*[^.]{64,})(?>([a-z0-9](?>[a-z0-9-]*[a-z0-9])?)(?>\.(?2)){0,126}|\[(?:(?>IPv6:(?>([a-f0-9]{1,4})(?>:(?3)){7}|(?!(?:.*[a-f0-9][:\]]){8,})((?3)(?>:(?3)){0,6})?::(?4)?))|(?>(?>IPv6:(?>(?3)(?>:(?3)){5}:|(?!(?:.*[a-f0-9]:){6,})(?5)?::(?>((?3)(?>:(?3)){0,4}):)?))?(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(?>\.(?6)){3}))\])$/iD'

Базовый:

Разрешает 9X_email-validation домен с точкой-атомом и локальной частью 9X_string-parsing имени домена (требуется как минимум две 9X_regular-expressions метки имени домена с ограничением длины 9X_validate TLD 2–6 буквенными символами).

"/^(?!.{255,})(?!.{65,}@)([!#-'*+\/-9=?^-~-]+)(?>\.(?1))*@(?!.*[^.]{64,})(?>[a-z0-9](?>[a-z0-9-]*[a-z0-9])?\.){1,126}[a-z]{2,6}$/iD"

11
0

Ответ #28

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Вот PHP, который я использую. Я выбрал это 9X_mail решение в духе «ложные срабатывания лучше, чем 9X_mail ложноотрицательные», как было заявлено здесь 9X_validate другим комментатором, И в отношении увеличения 9X_email-integration времени отклика и снижения нагрузки на сервер 9X_regex ... на самом деле нет необходимости тратить 9X_validation ресурсы сервера на регулярное выражение, которое 9X_email-validation отсеивает самые простые ошибки пользователя. Вы 9X_string-parsing всегда можете проверить это, отправив тестовое 9X_regex электронное письмо, если хотите.

function validateEmail($email) {
  return (bool) stripos($email,'@');
}

11
2

  • а) Полагаться на проверку JS, которая не удалась бы при отключении JavaScript, тоже не луч ...

Ответ #29

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Странно, что вы "не можете" разрешить 4-символьные 9X_mail TLD. Вы запрещаете людям посещать .info и .name, а 9X_string-parsing также ограничиваете длину .travel и .museum, но да, они 9X_email-validation встречаются реже, чем двухсимвольные TLD 9X_regular-expression и трехсимвольные TLD.

Вы также должны разрешить 9X_mail использование прописных букв. Системы электронной 9X_mail почты нормализуют локальную часть и доменную 9X_validate часть.

Для вашего регулярного выражения доменной 9X_validation части имя домена не может начинаться с "-" и 9X_form-validation не может заканчиваться на "-". Dash может 9X_regular-expressions оставаться только между ними.

Если вы использовали 9X_regex библиотеку PEAR, проверьте их почтовую функцию 9X_form-validation (забыли точное имя / библиотеку). Вы можете 9X_regular-expression проверить адрес электронной почты, вызвав 9X_string-parsing одну функцию, и она проверяет адрес электронной 9X_validation почты в соответствии с определением в RFC822.

8
1

  • @Joseph Yee: Разве RFC 822 не уст ...

Ответ #30

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Если вы не против принимать пустые значения 9X_validation (что не является недействительным адресом 9X_form-validation электронной почты) и используете PHP 5.2+, я 9X_string-parsing бы посоветовал:

static public function checkEmail($email, $ignore_empty = false) {
    if($ignore_empty && (is_null($email) || $email == ''))
            return true;
    return filter_var($email, FILTER_VALIDATE_EMAIL);
}

8
0

Ответ #31

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Я уже давно использую эту обновленную версию 9X_mail вашего регулярного выражения, и она не преподнесла 9X_string-parsing мне слишком много сюрпризов. Я никогда не встречал апострофа в электронном письме, поэтому он не подтверждает это . Он действительно 9X_email-validation проверяет Jean+François@anydomain.museum и 试@例子.测试.مثال.آزمایشی, но не странное злоупотребление 9X_regexp этими не буквенно-цифровыми символами .+@you.com.

(?!^[.+&'_-]*@.*$)(^[_\w\d+&'-]+(\.[_\w\d+&'-]*)*@[\w\d-]+(\.[\w\d-]+)*\.(([\d]{1,3})|([\w]{2,}))$)

Он 9X_email-integration поддерживает IP-адреса you@192.168.1.1, но я недостаточно 9X_validate доработал его для работы с поддельными диапазонами 9X_mail IP-адресов, такими как 999.999.999.1.

Он также поддерживает все TLD, состоящие из трех символов, что останавливает asdf@asdf.asdf, который, я думаю, пропускал оригинал. I've been beat, there are too many TLDs now over 3 characters.

Я знаю, что acrosman 9X_regexp отказался от своего регулярного выражения, но 9X_mail этот вкус живет.

7
0

Ответ #32

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

public bool ValidateEmail(string sEmail)
{
    if (sEmail == null)
    {
        return false;
    }

    int nFirstAT = sEmail.IndexOf('@');
    int nLastAT = sEmail.LastIndexOf('@');

    if ((nFirstAT > 0) && (nLastAT == nFirstAT) && (nFirstAT < (sEmail.Length - 1)))
    {
        return (Regex.IsMatch(sEmail, @"^[a-z|0-9|A-Z]*([_][a-z|0-9|A-Z]+)*([.][a-z|0-9|A-Z]+)*([.][a-z|0-9|A-Z]+)*(([_][a-z|0-9|A-Z]+)*)?@[a-z][a-z|0-9|A-Z]*\.([a-z][a-z|0-9|A-Z]*(\.[a-z][a-z|0-9|A-Z]*)?)$"));
    }
    else
    {
        return false;
    }
}

9X_regular-expression

7
0

Ответ #33

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Я не верю утверждению Борцмейера, приведенному 9X_string-parsing выше, о том, что «Грамматика (указанная 9X_validate в RFC 5322) слишком сложна для этого» (чтобы 9X_validation ее можно было обработать с помощью регулярного 9X_string-parsing выражения).

Вот грамматика: (из http://tools.ietf.org/html/rfc5322#section-3.4.1)

addr-spec       =   local-part "@" domain
local-part      =   dot-atom / quoted-string / obs-local-part
domain          =   dot-atom / domain-literal / obs-domain
domain-literal  =   [CFWS] "[" *([FWS] dtext) [FWS] "]" [CFWS]
dtext           =   %d33-90 /          ; Printable US-ASCII
                    %d94-126 /         ;  characters not including
                    obs-dtext          ;  "[", "]", or "\"

Если предположить, что 9X_email точка-атом, строка в кавычках, obs-local-part, obs-domain 9X_regular-expression сами являются обычными языками, это очень 9X_regexp простая грамматика. Просто замените local-part 9X_email и domain в продукте addr-spec на их соответствующие 9X_regular-expressions продукты, и у вас будет обычный язык, напрямую 9X_form-validation переводимый в регулярное выражение.

6
1

  • Вам следует изучить CFWS, прежде ч ...

Ответ #34

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Я использую многоэтапную проверку. Поскольку 9X_mail не существует идеального способа проверки 9X_mail адреса электронной почты, идеального сделать 9X_validation нельзя, но, по крайней мере, вы можете уведомить 9X_email-integration пользователя, что он / она делает что-то 9X_validation не так - вот мой подход

1) Сначала я проверяю 9X_regex с помощью самого простого регулярного выражения, которое 9X_regexp просто проверяет, содержит ли электронное 9X_form-validation письмо ровно один знак @ и не является ли 9X_validation оно пустым до или после этого знака. например 9X_string-parsing /^[^@\s]+@[^@\s]+$/

2a) если первый валидатор не проходит (а 9X_regexp для большинства адресов он должен, хотя 9X_regular-expressions и не идеален), предупредить пользователя 9X_validate о том, что адрес электронной почты недействителен, и 9X_email-validation не разрешить ему / ей продолжить ввод

2b), если 9X_regular-expressions он прошел, то проверьте соответствие более 9X_validate строгому регулярному выражению - что-то, что 9X_email может запрещать действительные электронные 9X_regular-expressions письма. Если этого не произошло, пользователь 9X_email будет предупрежден о возможной ошибке, но 9X_regular-expressions сможет продолжить. В отличие от шага (1), где 9X_email пользователю не разрешено продолжить, потому 9X_regular-expression что это очевидная ошибка.

Другими словами, первая 9X_validation либеральная проверка - это просто удаление 9X_form-validation очевидных ошибок, и она рассматривается 9X_regexp как «ошибка». Люди вводят пустой адрес, адрес 9X_regular-expressions без знака @ и так далее. Это следует рассматривать 9X_validate как ошибку. Второй является более строгим, но 9X_validate рассматривается как «предупреждение», и 9X_mail пользователю разрешается продолжить ввод, но 9X_regular-expressions с предупреждением, по крайней мере, проверить, ввел 9X_regular-expression ли он / она действительную запись. Ключевым 9X_validate моментом здесь является подход с ошибкой 9X_string-parsing / предупреждением - ошибка - это то, что 9X_form-validation в 99,99% случаев не может быть действительным 9X_email-validation адресом электронной почты.

Конечно, вы можете 9X_string-parsing настроить, что делает первое регулярное 9X_mail выражение более либеральным, а второе - более 9X_validate строгим.

В зависимости от того, что вам нужно, описанный 9X_validation выше подход может сработать для вас.

6
1

  • Согласен, но я никогда не утверждал, что мой метод на 100% надежен. Это работает в большинстве случаев. В какой-то момент вы должны быть реалистом и отбрасывать очень маловероятные случаи. Большинство адресов электронной почты — s ...

Ответ #35

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Я знаю, что этот вопрос касается RegEx, но 9X_mail предполагаю, что 90% всех разработчиков, читающих 9X_regexp эти решения, пытаются проверить адрес электронной 9X_string-parsing почты в HTML-форме, отображаемой в браузере.

В 9X_regular-expression этом случае я бы посоветовал проверить новый 9X_validation элемент формы HTML5 :

HTML5:

 

CSS3:

 input:required {
      background-color: rgba(255,0,0,0.2);
 }

 input:focus:invalid { 
     box-shadow: 0 0 1em red;
     border-color: red;
 }

 input:focus:valid { 
     box-shadow: 0 0 1em green;
     border-color: green;
 }

http://jsfiddle.net/mYRe7/1

У этого 9X_validate есть несколько преимуществ:

  1. Автоматическая проверка, никаких специальных решений не требуется: просто и легко реализовать.
  2. Нет JavaScript, нет проблем, если JS отключен.
  3. Для этого серверу не нужно ничего вычислять.
  4. Пользователь получает немедленную обратную связь.
  5. Старый браузер должен автоматически вернуться к типу ввода «текст».
  6. Мобильные браузеры могут отображать специализированную клавиатуру (@ -Keyboard).
  7. Отзыв о проверке формы очень прост с CSS3

Очевидным недостатком 9X_validate может быть отсутствие проверки для старых 9X_regular-expressions браузеров, но со временем ситуация изменится. Я 9X_form-validation бы предпочел это любому из этих безумных 9X_validation шедевров RegEx.

также смотрите:

6
0

Ответ #36

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Регулярное выражение для адреса электронной 9X_form-validation почты:

/^("(?:[!#-\[\]-\u{10FFFF}]|\\[\t -\u{10FFFF}])*"|[!#-'*+\-/-9=?A-Z\^-\u{10FFFF}](?:\.?[!#-'*+\-/-9=?A-Z\^-\u{10FFFF}])*)@([!#-'*+\-/-9=?A-Z\^-\u{10FFFF}](?:\.?[!#-'*+\-/-9=?A-Z\^-\u{10FFFF}])*|\[[!-Z\^-\u{10FFFF}]*\])$/u

Это регулярное выражение на 100% идентично 9X_validation ABNF addr-spec для не устаревших адресов электронной 9X_regular-expressions почты, как указано в RFC 5321, RFC 5322 и RFC 6532.

Кроме того, вы 9X_string-parsing должны подтвердить:

  • Адрес электронной почты - это правильно сформированный UTF-8 (или ASCII, если вы не можете отправлять на интернационализированные адреса электронной почты).
  • Адрес не превышает 320 байтов UTF-8.
  • Пользовательская часть (первая группа совпадений) не превышает 64 байта UTF-8.
  • Доменная часть (вторая группа совпадений) не более 255 байтов UTF-8.

Самый простой способ 9X_validation сделать все это - использовать существующую 9X_regexp функцию. В PHP просмотрите функцию filter_var, используя 9X_mail FILTER_VALIDATE_EMAIL и FILTER_FLAG_EMAIL_UNICODE (если вы можете отправлять сообщения 9X_form-validation на интернационализированные адреса электронной 9X_validation почты):

$email_valid = filter_var($email_input, FILTER_VALIDATE_EMAIL, FILTER_FLAG_EMAIL_UNICODE);

Однако, возможно, вы создаете такую 9X_regular-expressions ​​функцию - действительно, самый простой 9X_email-validation способ реализовать это - использовать регулярное 9X_regular-expressions выражение.

Помните, это только подтверждает, что 9X_validation адрес электронной почты не вызовет синтаксической 9X_regex ошибки. Единственный способ проверить, может 9X_regular-expressions ли адрес получать электронную почту, - это 9X_regex действительно отправить электронное письмо

.

Далее я расскажу, как 9X_email-validation вы генерируете это регулярное выражение.


Я 9X_form-validation пишу новый ответ, потому что в большинстве 9X_email-validation ответов здесь содержится ошибка, состоящая 9X_email-validation в том, что либо указывается слишком строгий 9X_mail шаблон (и, следовательно, он не устарел); или 9X_validate они представляют регулярное выражение, которое 9X_form-validation фактически соответствует заголовку сообщения 9X_validate MIME, а не самому адресу электронной почты.

Можно 9X_mail создать регулярное выражение из ABNF, если 9X_string-parsing нет рекурсивных частей.

RFC 5322 определяет, что 9X_regexp разрешено отправлять в MIME-сообщении; считайте 9X_regexp это верхней границей того, что является 9X_string-parsing юридическим адресом электронной почты.

Однако 9X_email-integration точно следовать этому ABNF было бы ошибкой: этот 9X_regexp шаблон технически представляет, как вы кодируете 9X_form-validation адрес электронной почты в сообщении MIME, и разрешает строки, не 9X_regexp являющиеся частью адреса электронной почты, например 9X_validation складывание пробелов и комментарии; и включает 9X_regex поддержку устаревших форм, создание которых 9X_validation запрещено законом (но которые серверы читают 9X_validate по историческим причинам). Адрес электронной 9X_regular-expressions почты не включает их.

RFC 5322 объясняет:

И 9X_validation атом, и точка-атом интерпретируются как 9X_email-integration единое целое, состоящее из строка символов, составляющих 9X_regular-expression его. Семантически необязательный комментарии 9X_email-integration и FWS, окружающие остальных персонажей, не 9X_regexp являются частью атома; атом - это всего 9X_string-parsing лишь набор текстовых символов в атоме, или 9X_validation текст и "." символы в виде точки-атома.

В 9X_email некоторых определениях будут нетерминалы, имена 9X_string-parsing которых начинать с "obs-". Эти 9X_string-parsing элементы "obs-" относятся к токенам, определенным 9X_validation в устаревший синтаксис в разделе 4. Во всех 9X_validation случаях эти продукты следует игнорировать 9X_validate в целях создания легального Интернета сообщения 9X_email-validation и НЕ ДОЛЖНЫ использоваться как часть такого 9X_regexp сообщения.

Если вы удалите правила CFWS, BWS и obs-* из 9X_regular-expressions addr-spec в RFC 5322 и выполните некоторую оптимизацию 9X_regex результата (я использовал "greenery"), вы можете создать 9X_email-validation это регулярное выражение, цитируется с косой 9X_email-integration чертой и закрепляется (подходит для использования 9X_validate в ECMAScript и совместимых диалектах, с 9X_mail добавлением новой строки для ясности):

/^("(?:[!#-\[\]-~]|\\[\t -~])*"|[!#-'*+\-/-9=?A-Z\^-~](?:\.?[!#-'*+\-/-9=?A-Z\^-~])*)
@([!#-'*+\-/-9=?A-Z\^-~](?:\.?[!#-'*+\-/-9=?A-Z\^-~])*|\[[!-Z\^-~]*\])$/

Поддерживаются 9X_mail только адреса электронной почты в формате 9X_email ASCII. Для поддержки RFC 6532 Internationalized Email Addresses замените символ ~ на 9X_mail \u{10FFFF} (PHP, ECMAScript с флагом u) или \uFFFF (для реализаций 9X_regexp UTF-16, таких как .Net и более ранние версии 9X_string-parsing ECMAScript / JavaScript): / p>

/^("(?:[!#-\[\]-\u{10FFFF}]|\\[\t -\u{10FFFF}])*"|[!#-'*+\-/-9=?A-Z\^-\u{10FFFF}](?:\.?[!#-'*+\-/-9=?A-Z\^-\u{10FFFF}])*)@([!#-'*+\-/-9=?A-Z\^-\u{10FFFF}](?:\.?[!#-'*+\-/-9=?A-Z\^-\u{10FFFF}])*|\[[!-Z\^-\u{10FFFF}]*\])$/u

Это работает, потому 9X_regular-expression что ABNF, который мы используем, не рекурсивен 9X_regexp и поэтому формирует нерекурсивную регулярную 9X_regex грамматику, которую можно преобразовать 9X_regex в регулярное выражение.

Вот как это выглядит:

  • Пользовательская часть (перед @) может быть точкой-атомом или строкой в ​​кавычках
  • "([!#-\[\]-~]|\\[\t -~])*" определяет форму строки в кавычках пользователя, например "root@home"@example.com. Он разрешает любой неконтролирующий символ заключать в двойные кавычки; за исключением того, что пробелы, табуляторы, двойные кавычки и обратные косые черты должны быть экранированы обратной косой чертой.
  • [!#-'*+\-/-9=?A-Z\^-~] - первый символ точки-атома пользователя.
  • (\.?[!#-'*+\-/-9=?A-Z\^-~])* соответствует остальной части точки-атома, разрешая точки (кроме как после другой точки или в качестве последнего символа).
  • @ обозначает домен.
  • Доменная часть может быть точкой-атомом или доменным литералом.
  • [!#-'*+\-/-9=?A-Z\^-~](\.?[!#-'*+\-/-9=?A-Z\^-~])* - это та же форма точка-атом, что и выше, но здесь она представляет доменные имена и адреса IPv4.
  • \[[!-Z\^-~]*\] будет соответствовать адресам IPv6 и будущим определениям имен хостов.

Это 9X_form-validation регулярное выражение позволяет использовать 9X_email-integration все соответствующие спецификации адреса 9X_string-parsing электронной почты и может использоваться 9X_regular-expressions дословно в сообщении MIME (за исключением 9X_email-validation ограничения длины строки, в этом случае 9X_form-validation необходимо добавить сворачивающиеся пробелы).

Это 9X_string-parsing также устанавливает группы без захвата, так 9X_regexp что match[1] будет пользователем, match[2] будет хостом. (Однако, если 9X_regex match[1] начинается с двойной кавычки, отфильтруйте 9X_form-validation экранирующие символы обратной косой черты, а 9X_regular-expressions также начальную и конечную двойные кавычки: "root"@example.com и 9X_email root@example.com идентифицируют один и тот же почтовый ящик.)

Наконец, обратите 9X_regexp внимание, что RFC 5321 устанавливает ограничения 9X_email на длину адреса электронной почты. Пользовательская 9X_regexp часть может иметь размер до 64 байтов, а 9X_email-integration доменная часть - до 255 байтов. Максимальный 9X_form-validation размер всего адреса, включая символ @, составляет 9X_email-validation 320 байт. Он измеряется в байтах после того, как 9X_email адрес закодирован в UTF-8; не символы.

Обратите 9X_string-parsing внимание, что RFC 5322 ABNF определяет разрешающий 9X_regex синтаксис для доменных имен, что позволяет 9X_email-validation именам, которые в настоящее время известны 9X_regex как недопустимые. Это также позволяет использовать 9X_regular-expressions доменные имена, которые в будущем могут 9X_regex стать законными. Это не должно быть проблемой, так 9X_regex как с этим следует обращаться так же, как 9X_regexp и с несуществующим доменным именем.

Всегда 9X_email-integration учитывайте возможность того, что пользователь 9X_email-integration ввел адрес электронной почты, который работает, но 9X_form-validation к которому у него нет доступа. Единственный надежный способ подтвердить адрес электронной почты - это отправить электронное письмо.

Это адаптировано 9X_regexp из моей статьи E-Mail Addresses & Syntax.

6
0

Ответ #37

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Мы уже несколько лет успешно используем 9X_string-parsing http://www.aspnetmx.com/. Вы можете выбрать уровень, на котором 9X_regexp хотите выполнить проверку (например, проверка 9X_validate синтаксиса, проверка домена, записей MX 9X_validate или фактического адреса электронной почты).

Для 9X_validation интерфейсных форм мы обычно проверяем наличие 9X_regexp домена и правильность синтаксиса, а затем 9X_email выполняем более строгую проверку, чтобы 9X_validation очистить нашу базу данных перед массовыми 9X_email-validation рассылками.

4
0

Ответ #38

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

это одно из регулярных выражений для электронной 9X_string-parsing почты

^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?$

4
0

Ответ #39

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Я всегда использую приведенное ниже регулярное 9X_email-validation выражение для проверки адреса электронной 9X_email почты. Это лучшее регулярное выражение, которое 9X_validate я когда-либо видел для проверки адреса электронной 9X_string-parsing почты.

"\A(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\Z";

Это регулярное выражение, которое 9X_string-parsing я всегда использую в моем коде Asp.NET, и 9X_validation мне оно очень нравится.

используйте эту ссылку 9X_regular-expressions на сборку

using System.Text.RegularExpressions;

и попробуйте следующий код, он 9X_regexp прост и сделает всю работу за вас.

private bool IsValidEmail(string email) {
    bool isValid = false;
    const string pattern = @"\A(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\Z";

    isValid = email != "" && Regex.IsMatch(email, pattern);

    // an alternative of the above line is also given and commented
    //
    //if (email == "") {
    //    isValid = false;
    //} else {
    //    // address provided so use the IsMatch Method
    //    // of the Regular Expression object
    //    isValid = Regex.IsMatch(email, pattern);
    //}
    return isValid;
}

эта функция 9X_email-integration проверяет строку электронной почты. Если 9X_regexp строка электронной почты имеет значение 9X_email null, она возвращает false, если строка 9X_validate электронной почты имеет неправильный формат, она 9X_email возвращает false. Он возвращает истину только 9X_email в том случае, если формат сообщения электронной 9X_email-validation почты действителен.

4
2

  • Это для стандартных почтовых серверов со стандартными символами. В случае, если язык не ...

Ответ #40

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Это правило соответствует тому, на что наш 9X_regular-expression постфиксный сервер не мог отправить.

разрешить 9X_regexp буквы, цифры, -, _, +,., &, /,!

нет -foo@bar.com

нет 9X_regular-expression asd@-bar.com

/^([a-z0-9\+\._\/&!][-a-z0-9\+\._\/&!]*)@(([a-z0-9][-a-z0-9]*\.)([-a-z0-9]+\.)*[a-z]{2,})$/i

4
0

Ответ #41

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Для PHP я использую валидатор адресов электронной 9X_regular-expression почты из Nette Framework - http://api.nette.org/2.3.3/source-Utils.Validators.php.html#234-247

/* public static */ function isEmail($value)
{
    $atom = "[-a-z0-9!#$%&'*+/=?^_`{|}~]"; // RFC 5322 unquoted characters in local-part
    $localPart = "(?:\"(?:[ !\\x23-\\x5B\\x5D-\\x7E]*|\\\\[ -~])+\"|$atom+(?:\\.$atom+)*)"; // quoted or unquoted
    $alpha = "a-z\x80-\xFF"; // superset of IDN
    $domain = "[0-9$alpha](?:[-0-9$alpha]{0,61}[0-9$alpha])?"; // RFC 1034 one domain component
    $topDomain = "[$alpha](?:[-0-9$alpha]{0,17}[$alpha])?";
    return (bool) preg_match("(^$localPart@(?:$domain\\.)+$topDomain\\z)i", $value);
}

4
0

Ответ #42

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Я все еще использую:

^[A-Za-z0-9._+\-\']+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}$

Но, возможно, с появлением 9X_regex IPv6 и Unicode:

^\w[^@\s]*@[^@\s]{2,}$

лучше всего. Gmail уже позволяет 9X_email-validation использовать последовательные точки, но 9X_email-integration Microsoft Exchange Server 2007 их отвергает.

4
1

  • Каждый раз, когда в ...

Ответ #43

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Почти все регулярные выражения, которые 9X_email я видел, в том числе некоторые, используемые 9X_email Microsoft, не позволяют пройти следующую 9X_regex действительную электронную почту: simon-@hotmail.com

Только что был реальный 9X_regular-expression покупатель с адресом электронной почты в 9X_form-validation таком формате, который не смог разместить 9X_validation заказ.

Вот на чем я остановился:

  • Минимальное регулярное выражение без ложных отрицаний. В качестве альтернативы используйте конструктор MailAddress с некоторыми дополнительными проверками (см. Ниже):
  • Проверка типичных опечаток .cmo или .gmial.com и запрос подтверждения Are you sure this is your correct email address. It looks like there may be a mistake. Разрешить пользователю принимать введенные данные, если они уверены.
  • Обработка отказов, когда электронное письмо действительно отправлено, и их ручная проверка для выявления очевидных ошибок.

        try
        {
            var email = new MailAddress(str);

            if (email.Host.EndsWith(".cmo"))
            {
                return EmailValidation.PossibleTypo;
            }

            if (!email.Host.EndsWith(".") && email.Host.Contains("."))
            {
                return EmailValidation.OK;
            }
        }
        catch
        {
            return EmailValidation.Invalid;
        }

4
2

  • Первый ответ на это сообщение проходит н ...

Ответ #44

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Для меня правильный способ проверки электронной 9X_email почты:

  1. Убедитесь, что символ @ существует, а до и после него есть некоторые символы, отличные от @: /^[^@]+@[^@]+$/
  2. Попробуйте отправить электронное письмо на этот адрес с некоторым «кодом активации».
  3. Когда пользователь "активировал" свой адрес электронной почты, мы увидим, что все в порядке.

Конечно, вы можете показывать предупреждение 9X_regexp или всплывающую подсказку во внешнем интерфейсе, когда 9X_validation пользователь набирает «странное» электронное 9X_regular-expressions письмо, чтобы помочь ему избежать распространенных 9X_regular-expression ошибок, таких как отсутствие точки в части 9X_email-integration домена или пробелов в имени без кавычек 9X_form-validation и т. д. Но вы должны принять адрес «hello 9X_regular-expressions @ world», если пользователь действительно 9X_regular-expression этого хочет.

Кроме того, вы должны помнить, что 9X_email-validation стандарт адресов электронной почты был и 9X_email-integration может развиваться, поэтому вы не можете 9X_regular-expressions просто вводить какое-нибудь «стандартное» регулярное 9X_email-integration выражение раз и навсегда. И вы должны помнить, что 9X_regular-expression некоторые конкретные интернет-серверы могут 9X_email-validation отказывать некоторым деталям общего стандарта 9X_email и фактически работать с собственным «модифицированным 9X_regexp стандартом».

Итак, просто отметьте @, назовите 9X_string-parsing пользователя на веб-интерфейсе и отправьте 9X_email письмо с подтверждением на указанный адрес.

4
0

Ответ #45

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Согласно RFC 2821 и RFC 2822, локальная часть адресов электронной 9X_regular-expression почты может использовать любой из этих символов 9X_regex ASCII:

  1. Прописные и строчные буквы
  2. Цифры от 0 до 9
  3. Символы! # $% & '* + - / =? ^ _ `{|} ~
  4. Символ "." при условии, что это не первый или последний символ в локальной части.

Матчи:

  • a&d@somedomain.com
  • a*d@somedomain.com
  • a/d@somedomain.com

Несоответствия:

  • .abc @ somedomain.com
  • abc. @ somedomain.com
  • a> b@somedomain.com

Для тех, которые 9X_email-validation соответствуют RFC 2821, 2822, вы можете 9X_validate использовать:

^((([!#$%&'*+\-/=?^_`{|}~\w])|([!#$%&'*+\-/=?^_`{|}~\w][!#$%&'*+\-/=?^_`{|}~\.\w]{0,}[!#$%&'*+\-/=?^_`{|}~\w]))[@]\w+([-.]\w+)*\.\w+([-.]\w+)*)$

Email - RFC 2821, 2822 Compliant

4
0

Ответ #46

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Хотя очень подробные ответы уже добавлены, я 9X_regular-expression думаю, что они достаточно сложны для разработчика, который 9X_form-validation просто ищет простой метод для проверки адреса 9X_regex электронной почты или получения всех адресов 9X_form-validation электронной почты из строки в Java.

public static boolean isEmailValid(@NonNull String email) {
    return android.util.Patterns.EMAIL_ADDRESS.matcher(email).matches();
}

Что касается 9X_validation регулярного выражения, я всегда использую 9X_form-validation это регулярное выражение, которое подходит 9X_email-integration для моих проблем.

"[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,6}"

Если вы хотите найти все 9X_regex адреса электронной почты в строке, сопоставив 9X_email-validation регулярное выражение электронной почты. Вы 9X_email-integration можете найти метод на this link.

4
0

Ответ #47

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

хм, странно не видеть этот ответ уже в ответах. Вот 9X_email-integration тот, который я построил. Это не пуленепробиваемая 9X_mail версия, но она «простая» и проверяет почти 9X_email-integration все.

[\w+-]+(?:\.[\w+-]+)*@[\w+-]+(?:\.[\w+-]+)*(?:\.[a-zA-Z]{2,4})

Думаю, есть объяснение, поэтому вы можете 9X_string-parsing изменить его, если хотите:

(e) [\w+-]+ соответствует 9X_email-validation a-z, A-Z, _, +, - хотя бы один раз

(m) (?:\.[\w+-]+)* соответствует 9X_mail a-z, A-Z, _, +, - ноль или более раз, но 9X_regexp нужно начинать с a. (точка)

@ = @

(i) [\w+-]+ соответствует 9X_form-validation a-z, A-Z, _, +, - хотя бы один раз

(l) (?:\.[\w+-]+)* соответствует 9X_email a-z, A-Z, _, +, - ноль или более раз, но 9X_form-validation должен начинаться с a. (точка)

(com) (?:\.[a-zA-Z]{2,4}) соответствует 9X_mail a-z, A-Z от 2 до 4 раз, начиная с a. (точка)

с 9X_email указанием e(.m)@i(.l).com, где (.m) и (.l) являются необязательными, но 9X_string-parsing также могут повторяться несколько раз. Я 9X_regex думаю, что это проверяет все действительные 9X_regular-expressions адреса электронной почты, но блокирует потенциально 9X_form-validation недействительные без использования слишком 9X_validate сложного регулярного выражения, которое 9X_regular-expressions в большинстве случаев не требуется.

обратите 9X_mail внимание, что это позволит +@-.com, но это компромисс 9X_regexp для упрощения.

3
0

Ответ #48

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Сейчас существует намного больше (тысячи) TLD. За 9X_validate большинство приведенных здесь ответов необходимо 9X_validate проголосовать, поскольку они больше не верны 9X_string-parsing - возможно, у этого вопроса должно быть 9X_validation второе издание.

Не стесняйтесь посетить a more current discussion on other post....

3
1

  • Это определенно одна из самых идиотских проблем с сетью SE - сайт вопросов и ответов для некоторых из самых быстро развивающихся отраслей в мире, который активно препятствует появлению новых о ...

Ответ #49

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Если вы хотите улучшить регулярное выражение, которое 9X_regular-expressions достаточно хорошо работало на протяжении 9X_regular-expression нескольких лет, то ответ зависит от того, чего 9X_regexp именно вы хотите достичь - какие адреса 9X_regex электронной почты не работают. Тонкая настройка 9X_regex регулярных выражений электронной почты очень 9X_regexp сложна, и я еще не нашел идеального решения.

  • Если ваше приложение включает в себя что-то очень техническое по своей природе (или что-то внутреннее для организаций), тогда, возможно, вам нужно поддерживать IP-адреса вместо доменных имен или комментариев в «локальной» части адреса электронной почты.
  • Если ваше приложение является многонациональным, я бы подумал о поддержке Unicode / UTF8.

Основной 9X_regex ответ на ваш вопрос в настоящее время связан 9X_regexp с "регулярным выражением, полностью 9X_email-validation совместимым с RFC ‑ 822". Однако, несмотря 9X_form-validation на сложность этого регулярного выражения 9X_validation и предполагаемое внимание к деталям в правилах 9X_regular-expression RFC, оно полностью не работает, когда дело 9X_regular-expressions доходит до поддержки Unicode.

Регулярное 9X_string-parsing выражение, которое я написал для большинства 9X_email-validation своих приложений, сосредоточено на поддержке 9X_mail Unicode, а также на разумном общем соблюдении стандартов 9X_validate RFC:

/^(?!\.)((?!.*\.{2})[a-zA-Z0-9\u0080-\u00FF\u0100-\u017F\u0180-\u024F\u0250-\u02AF\u0300-\u036F\u0370-\u03FF\u0400-\u04FF\u0500-\u052F\u0530-\u058F\u0590-\u05FF\u0600-\u06FF\u0700-\u074F\u0750-\u077F\u0780-\u07BF\u07C0-\u07FF\u0900-\u097F\u0980-\u09FF\u0A00-\u0A7F\u0A80-\u0AFF\u0B00-\u0B7F\u0B80-\u0BFF\u0C00-\u0C7F\u0C80-\u0CFF\u0D00-\u0D7F\u0D80-\u0DFF\u0E00-\u0E7F\u0E80-\u0EFF\u0F00-\u0FFF\u1000-\u109F\u10A0-\u10FF\u1100-\u11FF\u1200-\u137F\u1380-\u139F\u13A0-\u13FF\u1400-\u167F\u1680-\u169F\u16A0-\u16FF\u1700-\u171F\u1720-\u173F\u1740-\u175F\u1760-\u177F\u1780-\u17FF\u1800-\u18AF\u1900-\u194F\u1950-\u197F\u1980-\u19DF\u19E0-\u19FF\u1A00-\u1A1F\u1B00-\u1B7F\u1D00-\u1D7F\u1D80-\u1DBF\u1DC0-\u1DFF\u1E00-\u1EFF\u1F00-\u1FFFu20D0-\u20FF\u2100-\u214F\u2C00-\u2C5F\u2C60-\u2C7F\u2C80-\u2CFF\u2D00-\u2D2F\u2D30-\u2D7F\u2D80-\u2DDF\u2F00-\u2FDF\u2FF0-\u2FFF\u3040-\u309F\u30A0-\u30FF\u3100-\u312F\u3130-\u318F\u3190-\u319F\u31C0-\u31EF\u31F0-\u31FF\u3200-\u32FF\u3300-\u33FF\u3400-\u4DBF\u4DC0-\u4DFF\u4E00-\u9FFF\uA000-\uA48F\uA490-\uA4CF\uA700-\uA71F\uA800-\uA82F\uA840-\uA87F\uAC00-\uD7AF\uF900-\uFAFF\.!#$%&'*+-/=?^_`{|}~\-\d]+)@(?!\.)([a-zA-Z0-9\u0080-\u00FF\u0100-\u017F\u0180-\u024F\u0250-\u02AF\u0300-\u036F\u0370-\u03FF\u0400-\u04FF\u0500-\u052F\u0530-\u058F\u0590-\u05FF\u0600-\u06FF\u0700-\u074F\u0750-\u077F\u0780-\u07BF\u07C0-\u07FF\u0900-\u097F\u0980-\u09FF\u0A00-\u0A7F\u0A80-\u0AFF\u0B00-\u0B7F\u0B80-\u0BFF\u0C00-\u0C7F\u0C80-\u0CFF\u0D00-\u0D7F\u0D80-\u0DFF\u0E00-\u0E7F\u0E80-\u0EFF\u0F00-\u0FFF\u1000-\u109F\u10A0-\u10FF\u1100-\u11FF\u1200-\u137F\u1380-\u139F\u13A0-\u13FF\u1400-\u167F\u1680-\u169F\u16A0-\u16FF\u1700-\u171F\u1720-\u173F\u1740-\u175F\u1760-\u177F\u1780-\u17FF\u1800-\u18AF\u1900-\u194F\u1950-\u197F\u1980-\u19DF\u19E0-\u19FF\u1A00-\u1A1F\u1B00-\u1B7F\u1D00-\u1D7F\u1D80-\u1DBF\u1DC0-\u1DFF\u1E00-\u1EFF\u1F00-\u1FFF\u20D0-\u20FF\u2100-\u214F\u2C00-\u2C5F\u2C60-\u2C7F\u2C80-\u2CFF\u2D00-\u2D2F\u2D30-\u2D7F\u2D80-\u2DDF\u2F00-\u2FDF\u2FF0-\u2FFF\u3040-\u309F\u30A0-\u30FF\u3100-\u312F\u3130-\u318F\u3190-\u319F\u31C0-\u31EF\u31F0-\u31FF\u3200-\u32FF\u3300-\u33FF\u3400-\u4DBF\u4DC0-\u4DFF\u4E00-\u9FFF\uA000-\uA48F\uA490-\uA4CF\uA700-\uA71F\uA800-\uA82F\uA840-\uA87F\uAC00-\uD7AF\uF900-\uFAFF\-\.\d]+)((\.([a-zA-Z\u0080-\u00FF\u0100-\u017F\u0180-\u024F\u0250-\u02AF\u0300-\u036F\u0370-\u03FF\u0400-\u04FF\u0500-\u052F\u0530-\u058F\u0590-\u05FF\u0600-\u06FF\u0700-\u074F\u0750-\u077F\u0780-\u07BF\u07C0-\u07FF\u0900-\u097F\u0980-\u09FF\u0A00-\u0A7F\u0A80-\u0AFF\u0B00-\u0B7F\u0B80-\u0BFF\u0C00-\u0C7F\u0C80-\u0CFF\u0D00-\u0D7F\u0D80-\u0DFF\u0E00-\u0E7F\u0E80-\u0EFF\u0F00-\u0FFF\u1000-\u109F\u10A0-\u10FF\u1100-\u11FF\u1200-\u137F\u1380-\u139F\u13A0-\u13FF\u1400-\u167F\u1680-\u169F\u16A0-\u16FF\u1700-\u171F\u1720-\u173F\u1740-\u175F\u1760-\u177F\u1780-\u17FF\u1800-\u18AF\u1900-\u194F\u1950-\u197F\u1980-\u19DF\u19E0-\u19FF\u1A00-\u1A1F\u1B00-\u1B7F\u1D00-\u1D7F\u1D80-\u1DBF\u1DC0-\u1DFF\u1E00-\u1EFF\u1F00-\u1FFF\u20D0-\u20FF\u2100-\u214F\u2C00-\u2C5F\u2C60-\u2C7F\u2C80-\u2CFF\u2D00-\u2D2F\u2D30-\u2D7F\u2D80-\u2DDF\u2F00-\u2FDF\u2FF0-\u2FFF\u3040-\u309F\u30A0-\u30FF\u3100-\u312F\u3130-\u318F\u3190-\u319F\u31C0-\u31EF\u31F0-\u31FF\u3200-\u32FF\u3300-\u33FF\u3400-\u4DBF\u4DC0-\u4DFF\u4E00-\u9FFF\uA000-\uA48F\uA490-\uA4CF\uA700-\uA71F\uA800-\uA82F\uA840-\uA87F\uAC00-\uD7AF\uF900-\uFAFF]){2,63})+)$/i

Я не буду копировать и вставлять полные 9X_email-integration ответы, поэтому просто свяжу это с аналогичным 9X_mail ответом, который я предоставил здесь: How to validate a unicode email?

Существует 9X_validate также живая демонстрация для регулярного 9X_regex выражения выше по адресу: http://jsfiddle.net/aossikine/qCLVH/3/

3
0

Ответ #50

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Регулярные выражения, опубликованные в этой 9X_string-parsing цепочке, теперь устарели из-за появления 9X_validate новых общих доменов верхнего уровня (gTLD) (например, .london, .basketball,. 通 9X_email-validation 販). Для проверки адреса электронной почты 9X_email есть два ответа (которые подходят для подавляющего 9X_email большинства).

  1. Как говорится в основном ответе - не используйте регулярное выражение, просто проверьте его, отправив электронное письмо на адрес (перехватить исключения для недопустимых адресов)
  2. Используйте очень общее регулярное выражение, чтобы, по крайней мере, убедиться, что они используют структуру электронной почты {something}@{something}.{something}. Нет смысла использовать подробное регулярное выражение, потому что вы не поймаете их все, и через несколько лет появится новый пакет, и вам придется снова обновить свое регулярное выражение.

Я решил использовать регулярное 9X_form-validation выражение, потому что, к сожалению, некоторые 9X_regex пользователи не читают формы и вводят неправильные 9X_regular-expressions данные в неправильные поля. Это, по крайней 9X_form-validation мере, предупредит их, когда они попытаются 9X_email-validation ввести что-то, что не является электронным 9X_email письмом, в поле ввода электронной почты, и 9X_regexp должно сэкономить вам время, поддерживая 9X_mail пользователей по вопросам электронной почты.

(.+)@(.+){2,}\.(.+){2,}

3
0

Ответ #51

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Ниже приводится регулярное выражение для 9X_regexp проверки адреса электронной почты

^.+@\w+(\.\w+)+$

3
0

Ответ #52

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Я не нашел ни одного, связанного с доменным 9X_email-validation именем верхнего уровня, но это следует учитывать.

Итак, для 9X_regex меня сработало следующее:

[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+(?:[A-Z]{2}AAA|AARP|ABB|ABBOTT|ABOGADO|AC|ACADEMY|ACCENTURE|ACCOUNTANT|ACCOUNTANTS|ACO|ACTIVE|ACTOR|AD|ADAC|ADS|ADULT|AE|AEG|AERO|AF|AFL|AG|AGENCY|AI|AIG|AIRFORCE|AIRTEL|AL|ALIBABA|ALIPAY|ALLFINANZ|ALSACE|AM|AMICA|AMSTERDAM|ANALYTICS|ANDROID|AO|APARTMENTS|APP|APPLE|AQ|AQUARELLE|AR|ARAMCO|ARCHI|ARMY|ARPA|ARTE|AS|ASIA|ASSOCIATES|AT|ATTORNEY|AU|AUCTION|AUDI|AUDIO|AUTHOR|AUTO|AUTOS|AW|AX|AXA|AZ|AZURE|BA|BAIDU|BAND|BANK|BAR|BARCELONA|BARCLAYCARD|BARCLAYS|BARGAINS|BAUHAUS|BAYERN|BB|BBC|BBVA|BCN|BD|BE|BEATS|BEER|BENTLEY|BERLIN|BEST|BET|BF|BG|BH|BHARTI|BI|BIBLE|BID|BIKE|BING|BINGO|BIO|BIZ|BJ|BLACK|BLACKFRIDAY|BLOOMBERG|BLUE|BM|BMS|BMW|BN|BNL|BNPPARIBAS|BO|BOATS|BOEHRINGER|BOM|BOND|BOO|BOOK|BOOTS|BOSCH|BOSTIK|BOT|BOUTIQUE|BR|BRADESCO|BRIDGESTONE|BROADWAY|BROKER|BROTHER|BRUSSELS|BS|BT|BUDAPEST|BUGATTI|BUILD|BUILDERS|BUSINESS|BUY|BUZZ|BV|BW|BY|BZ|BZH|CA|CAB|CAFE|CAL|CALL|CAMERA|CAMP|CANCERRESEARCH|CANON|CAPETOWN|CAPITAL|CAR|CARAVAN|CARDS|CARE|CAREER|CAREERS|CARS|CARTIER|CASA|CASH|CASINO|CAT|CATERING|CBA|CBN|CC|CD|CEB|CENTER|CEO|CERN|CF|CFA|CFD|CG|CH|CHANEL|CHANNEL|CHAT|CHEAP|CHLOE|CHRISTMAS|CHROME|CHURCH|CI|CIPRIANI|CIRCLE|CISCO|CITIC|CITY|CITYEATS|CK|CL|CLAIMS|CLEANING|CLICK|CLINIC|CLINIQUE|CLOTHING|CLOUD|CLUB|CLUBMED|CM|CN|CO|COACH|CODES|COFFEE|COLLEGE|COLOGNE|COM|COMMBANK|COMMUNITY|COMPANY|COMPARE|COMPUTER|COMSEC|CONDOS|CONSTRUCTION|CONSULTING|CONTACT|CONTRACTORS|COOKING|COOL|COOP|CORSICA|COUNTRY|COUPONS|COURSES|CR|CREDIT|CREDITCARD|CREDITUNION|CRICKET|CROWN|CRS|CRUISES|CSC|CU|CUISINELLA|CV|CW|CX|CY|CYMRU|CYOU|CZ|DABUR|DAD|DANCE|DATE|DATING|DATSUN|DAY|DCLK|DE|DEALER|DEALS|DEGREE|DELIVERY|DELL|DELTA|DEMOCRAT|DENTAL|DENTIST|DESI|DESIGN|DEV|DIAMONDS|DIET|DIGITAL|DIRECT|DIRECTORY|DISCOUNT|DJ|DK|DM|DNP|DO|DOCS|DOG|DOHA|DOMAINS|DOOSAN|DOWNLOAD|DRIVE|DUBAI|DURBAN|DVAG|DZ|EARTH|EAT|EC|EDEKA|EDU|EDUCATION|EE|EG|EMAIL|EMERCK|ENERGY|ENGINEER|ENGINEERING|ENTERPRISES|EPSON|EQUIPMENT|ER|ERNI|ES|ESQ|ESTATE|ET|EU|EUROVISION|EUS|EVENTS|EVERBANK|EXCHANGE|EXPERT|EXPOSED|EXPRESS|FAGE|FAIL|FAIRWINDS|FAITH|FAMILY|FAN|FANS|FARM|FASHION|FAST|FEEDBACK|FERRERO|FI|FILM|FINAL|FINANCE|FINANCIAL|FIRESTONE|FIRMDALE|FISH|FISHING|FIT|FITNESS|FJ|FK|FLIGHTS|FLORIST|FLOWERS|FLSMIDTH|FLY|FM|FO|FOO|FOOTBALL|FORD|FOREX|FORSALE|FORUM|FOUNDATION|FOX|FR|FRESENIUS|FRL|FROGANS|FUND|FURNITURE|FUTBOL|FYI|GA|GAL|GALLERY|GAME|GARDEN|GB|GBIZ|GD|GDN|GE|GEA|GENT|GENTING|GF|GG|GGEE|GH|GI|GIFT|GIFTS|GIVES|GIVING|GL|GLASS|GLE|GLOBAL|GLOBO|GM|GMAIL|GMO|GMX|GN|GOLD|GOLDPOINT|GOLF|GOO|GOOG|GOOGLE|GOP|GOT|GOV|GP|GQ|GR|GRAINGER|GRAPHICS|GRATIS|GREEN|GRIPE|GROUP|GS|GT|GU|GUCCI|GUGE|GUIDE|GUITARS|GURU|GW|GY|HAMBURG|HANGOUT|HAUS|HEALTH|HEALTHCARE|HELP|HELSINKI|HERE|HERMES|HIPHOP|HITACHI|HIV|HK|HM|HN|HOCKEY|HOLDINGS|HOLIDAY|HOMEDEPOT|HOMES|HONDA|HORSE|HOST|HOSTING|HOTELES|HOTMAIL|HOUSE|HOW|HR|HSBC|HT|HU|HYUNDAI|IBM|ICBC|ICE|ICU|ID|IE|IFM|IINET|IL|IM|IMMO|IMMOBILIEN|IN|INDUSTRIES|INFINITI|INFO|ING|INK|INSTITUTE|INSURANCE|INSURE|INT|INTERNATIONAL|INVESTMENTS|IO|IPIRANGA|IQ|IR|IRISH|IS|ISELECT|IST|ISTANBUL|IT|ITAU|IWC|JAGUAR|JAVA|JCB|JE|JETZT|JEWELRY|JLC|JLL|JM|JMP|JO|JOBS|JOBURG|JOT|JOY|JP|JPRS|JUEGOS|KAUFEN|KDDI|KE|KFH|KG|KH|KI|KIA|KIM|KINDER|KITCHEN|KIWI|KM|KN|KOELN|KOMATSU|KP|KPN|KR|KRD|KRED|KW|KY|KYOTO|KZ|LA|LACAIXA|LAMBORGHINI|LAMER|LANCASTER|LAND|LANDROVER|LANXESS|LASALLE|LAT|LATROBE|LAW|LAWYER|LB|LC|LDS|LEASE|LECLERC|LEGAL|LEXUS|LGBT|LI|LIAISON|LIDL|LIFE|LIFEINSURANCE|LIFESTYLE|LIGHTING|LIKE|LIMITED|LIMO|LINCOLN|LINDE|LINK|LIVE|LIVING|LIXIL|LK|LOAN|LOANS|LOL|LONDON|LOTTE|LOTTO|LOVE|LR|LS|LT|LTD|LTDA|LU|LUPIN|LUXE|LUXURY|LV|LY|MA|MADRID|MAIF|MAISON|MAKEUP|MAN|MANAGEMENT|MANGO|MARKET|MARKETING|MARKETS|MARRIOTT|MBA|MC|MD|ME|MED|MEDIA|MEET|MELBOURNE|MEME|MEMORIAL|MEN|MENU|MEO|MG|MH|MIAMI|MICROSOFT|MIL|MINI|MK|ML|MM|MMA|MN|MO|MOBI|MOBILY|MODA|MOE|MOI|MOM|MONASH|MONEY|MONTBLANC|MORMON|MORTGAGE|MOSCOW|MOTORCYCLES|MOV|MOVIE|MOVISTAR|MP|MQ|MR|MS|MT|MTN|MTPC|MTR|MU|MUSEUM|MUTUELLE|MV|MW|MX|MY|MZ|NA|NADEX|NAGOYA|NAME|NAVY|NC|NE|NEC|NET|NETBANK|NETWORK|NEUSTAR|NEW|NEWS|NEXUS|NF|NG|NGO|NHK|NI|NICO|NINJA|NISSAN|NL|NO|NOKIA|NORTON|NOWRUZ|NP|NR|NRA|NRW|NTT|NU|NYC|NZ|OBI|OFFICE|OKINAWA|OM|OMEGA|ONE|ONG|ONL|ONLINE|OOO|ORACLE|ORANGE|ORG|ORGANIC|ORIGINS|OSAKA|OTSUKA|OVH|PA|PAGE|PAMPEREDCHEF|PANERAI|PARIS|PARS|PARTNERS|PARTS|PARTY|PE|PET|PF|PG|PH|PHARMACY|PHILIPS|PHOTO|PHOTOGRAPHY|PHOTOS|PHYSIO|PIAGET|PICS|PICTET|PICTURES|PID|PIN|PING|PINK|PIZZA|PK|PL|PLACE|PLAY|PLAYSTATION|PLUMBING|PLUS|PM|PN|POHL|POKER|PORN|POST|PR|PRAXI|PRESS|PRO|PROD|PRODUCTIONS|PROF|PROMO|PROPERTIES|PROPERTY|PROTECTION|PS|PT|PUB|PW|PY|QA|QPON|QUEBEC|RACING|RE|READ|REALTOR|REALTY|RECIPES|RED|REDSTONE|REDUMBRELLA|REHAB|REISE|REISEN|REIT|REN|RENT|RENTALS|REPAIR|REPORT|REPUBLICAN|REST|RESTAURANT|REVIEW|REVIEWS|REXROTH|RICH|RICOH|RIO|RIP|RO|ROCHER|ROCKS|RODEO|ROOM|RS|RSVP|RU|RUHR|RUN|RW|RWE|RYUKYU|SA|SAARLAND|SAFE|SAFETY|SAKURA|SALE|SALON|SAMSUNG|SANDVIK|SANDVIKCOROMANT|SANOFI|SAP|SAPO|SARL|SAS|SAXO|SB|SBS|SC|SCA|SCB|SCHAEFFLER|SCHMIDT|SCHOLARSHIPS|SCHOOL|SCHULE|SCHWARZ|SCIENCE|SCOR|SCOT|SD|SE|SEAT|SECURITY|SEEK|SELECT|SENER|SERVICES|SEVEN|SEW|SEX|SEXY|SFR|SG|SH|SHARP|SHELL|SHIA|SHIKSHA|SHOES|SHOW|SHRIRAM|SI|SINGLES|SITE|SJ|SK|SKI|SKIN|SKY|SKYPE|SL|SM|SMILE|SN|SNCF|SO|SOCCER|SOCIAL|SOFTBANK|SOFTWARE|SOHU|SOLAR|SOLUTIONS|SONY|SOY|SPACE|SPIEGEL|SPREADBETTING|SR|SRL|ST|STADA|STAR|STARHUB|STATEFARM|STATOIL|STC|STCGROUP|STOCKHOLM|STORAGE|STUDIO|STUDY|STYLE|SU|SUCKS|SUPPLIES|SUPPLY|SUPPORT|SURF|SURGERY|SUZUKI|SV|SWATCH|SWISS|SX|SY|SYDNEY|SYMANTEC|SYSTEMS|SZ|TAB|TAIPEI|TAOBAO|TATAMOTORS|TATAR|TATTOO|TAX|TAXI|TC|TCI|TD|TEAM|TECH|TECHNOLOGY|TEL|TELEFONICA|TEMASEK|TENNIS|TF|TG|TH|THD|THEATER|THEATRE|TICKETS|TIENDA|TIFFANY|TIPS|TIRES|TIROL|TJ|TK|TL|TM|TMALL|TN|TO|TODAY|TOKYO|TOOLS|TOP|TORAY|TOSHIBA|TOURS|TOWN|TOYOTA|TOYS|TR|TRADE|TRADING|TRAINING|TRAVEL|TRAVELERS|TRAVELERSINSURANCE|TRUST|TRV|TT|TUBE|TUI|TUSHU|TV|TW|TZ|UA|UBS|UG|UK|UNIVERSITY|UNO|UOL|US|UY|UZ|VA|VACATIONS|VANA|VC|VE|VEGAS|VENTURES|VERISIGN|VERSICHERUNG|VET|VG|VI|VIAJES|VIDEO|VILLAS|VIN|VIP|VIRGIN|VISION|VISTA|VISTAPRINT|VIVA|VLAANDEREN|VN|VODKA|VOLKSWAGEN|VOTE|VOTING|VOTO|VOYAGE|VU|WALES|WALTER|WANG|WANGGOU|WATCH|WATCHES|WEATHER|WEBCAM|WEBER|WEBSITE|WED|WEDDING|WEIR|WF|WHOSWHO|WIEN|WIKI|WILLIAMHILL|WIN|WINDOWS|WINE|WME|WORK|WORKS|WORLD|WS|WTC|WTF|XBOX|XEROX|XIN|XN--11B4C3D|XN--1QQW23A|XN--30RR7Y|XN--3BST00M|XN--3DS443G|XN--3E0B707E|XN--3PXU8K|XN--42C2D9A|XN--45BRJ9C|XN--45Q11C|XN--4GBRIM|XN--55QW42G|XN--55QX5D|XN--6FRZ82G|XN--6QQ986B3XL|XN--80ADXHKS|XN--80AO21A|XN--80ASEHDB|XN--80ASWG|XN--90A3AC|XN--90AIS|XN--9DBQ2A|XN--9ET52U|XN--B4W605FERD|XN--C1AVG|XN--C2BR7G|XN--CG4BKI|XN--CLCHC0EA0B2G2A9GCD|XN--CZR694B|XN--CZRS0T|XN--CZRU2D|XN--D1ACJ3B|XN--D1ALF|XN--ECKVDTC9D|XN--EFVY88H|XN--ESTV75G|XN--FHBEI|XN--FIQ228C5HS|XN--FIQ64B|XN--FIQS8S|XN--FIQZ9S|XN--FJQ720A|XN--FLW351E|XN--FPCRJ9C3D|XN--FZC2C9E2C|XN--G2XX48C|XN--GECRJ9C|XN--H2BRJ9C|XN--HXT814E|XN--I1B6B1A6A2E|XN--IMR513N|XN--IO0A7I|XN--J1AEF|XN--J1AMH|XN--J6W193G|XN--JLQ61U9W7B|XN--KCRX77D1X4A|XN--KPRW13D|XN--KPRY57D|XN--KPU716F|XN--KPUT3I|XN--L1ACC|XN--LGBBAT1AD8J|XN--MGB9AWBF|XN--MGBA3A3EJT|XN--MGBA3A4F16A|XN--MGBAAM7A8H|XN--MGBAB2BD|XN--MGBAYH7GPA|XN--MGBB9FBPOB|XN--MGBBH1A71E|XN--MGBC0A9AZCG|XN--MGBERP4A5D4AR|XN--MGBPL2FH|XN--MGBT3DHD|XN--MGBTX2B|XN--MGBX4CD0AB|XN--MK1BU44C|XN--MXTQ1M|XN--NGBC5AZD|XN--NGBE9E0A|XN--NODE|XN--NQV7F|XN--NQV7FS00EMA|XN--NYQY26A|XN--O3CW4H|XN--OGBPF8FL|XN--P1ACF|XN--P1AI|XN--PBT977C|XN--PGBS0DH|XN--PSSY2U|XN--Q9JYB4C|XN--QCKA1PMC|XN--QXAM|XN--RHQV96G|XN--S9BRJ9C|XN--SES554G|XN--T60B56A|XN--TCKWE|XN--UNUP4Y|XN--VERMGENSBERATER-CTB|XN--VERMGENSBERATUNG-PWB|XN--VHQUV|XN--VUQ861B|XN--WGBH1C|XN--WGBL6A|XN--XHQ521B|XN--XKC2AL3HYE2A|XN--XKC2DL3A5EE0H|XN--Y9A3AQ|XN--YFRO4I67O|XN--YGBI2AMMX|XN--ZFR164B|XPERIA|XXX|XYZ|YACHTS|YAMAXUN|YANDEX|YE|YODOBASHI|YOGA|YOKOHAMA|YOUTUBE|YT|ZA|ZARA|ZERO|ZIP|ZM|ZONE|ZUERICH|ZW)\b

Это легко отбрасываемые 9X_email электронные письма, такие как 3c296rD3HNEE@d139c.a51, Sd@sd.dox и т. д.

При 9X_validate необходимости доменное имя может быть отредактировано, например, домен 9X_regular-expression конкретной страны и т. д.

3
1

  • Даже на момент написания оригинала это уже было недействительным для пары сотен TLD. На данный момент вам не хватает чуть менее 1200 возможносте ...

Ответ #53

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Никто не упоминал о проблеме локализации 9X_email-integration (i18), что, если к вам приходят клиенты 9X_email-validation со всего мира? Затем вам нужно будет разбить 9X_regex ваше регулярное выражение на подкатегории 9X_form-validation для каждой страны / области, что, как я 9X_mail видел, разработчики заканчивали созданием 9X_form-validation большого словаря / конфигурации. Хорошей 9X_email-validation отправной точкой может быть определение 9X_form-validation языковых настроек браузера пользователей.

3
0

Ответ #54

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Я бы вообще не предлагал использовать регулярное 9X_string-parsing выражение - адреса электронной почты слишком 9X_regex сложны для этого. Это обычная проблема, поэтому 9X_regexp я предполагаю, что существует множество 9X_email-validation библиотек, содержащих валидатор - если вы 9X_mail используете Java, EmailValidator из apache commons validator - хороший вариант.

3
0

Ответ #55

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Насколько я понимаю, наиболее вероятно будет 9X_validation охватывать ..

/^([a-z0-9_-]+)(@[a-z0-9-]+)(\.[a-z]+|\.[a-z]+\.[a-z]+)?$/is

3
0

Ответ #56

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Если вам нужна простая форма для проверки, вы 9X_form-validation можете использовать ответ https://regexr.com/3e48o

^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$

let r = new RegExp(String.raw `^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$`);

//should be true
console.log(r.test('name@domain.tld'));
console.log(r.test('name@domain.co.tld'));
console.log(r.test('name@domain.co'));

//should be false
console.log(r.test('@domain.tld'));
console.log(r.test('name@.tld'));
console.log(r.test('name@domain.'));
console.log(r.test('namedomain.tld'));
console.log(r.test(''));

//now that basic client-side validation is done, send a token from the server side to validate the user actually has access to the email

3
1

  • Это регулярное выражение слишком простое и отклоняет обычные действительные электронные письма. Он неправильно отклоняет положительную частицу в локальной части (`foo + bar @ example.com`) и не ...

Ответ #57

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Я found a regular expression, который соответствует RFC 2822. Предыдущий 9X_string-parsing стандарт RFC 5322. Это регулярное выражение 9X_regular-expressions работает достаточно хорошо и охватывает 9X_email-validation большинство случаев, однако, когда RFC 5322 9X_string-parsing становится стандартом, могут возникнуть 9X_validation некоторые дыры, которые следует устранить. быть 9X_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])+)\])$

В документации говорится, что 9X_form-validation вы не должны использовать указанное выше 9X_mail регулярное выражение, а отдавайте предпочтение 9X_string-parsing этому варианту, который является немного 9X_regular-expression более управляемым.

[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?

Я заметил, что здесь учитывается 9X_validate регистр, поэтому я действительно внес изменения 9X_regular-expression в эту лендинг.

^[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?$

2
0

Ответ #58

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Элемент списка

Я использую эту функцию

function checkmail($value){
        $value = trim($value);
        if( stristr($value,"@") 
            && stristr($value,".") 
            && (strrpos($value, ".") - stripos($value, "@") > 2) 
            && (stripos($value, "@") > 1) 
            && (strlen($value) - strrpos($value, ".") < 6) 
            && (strlen($value) - strrpos($value, ".") > 2) 
            && ($value == preg_replace('/[ ]/', '', $value)) 
            && ($value == preg_replace('/[^A-Za-z0-9\-_.@!*]/', '', $value))
        ){

        }else{
            return "Invalid Mail-Id";
        }
    }

9X_validation

2
0

Ответ #59

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Java Mail API творит с нами чудеса

try
    {
     InternetAddress internetAddress = new InternetAddress(email);
     internetAddress.validate();
     return true;
    }
    catch(Exception ex)
    {
        return false;
    }

Я получил это от here

9X_string-parsing

2
1

  • Java Mail API - это _опциональный пакет для использования с платформой Java SE_, который включен в плат ...

Ответ #60

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Написание регулярного выражения для всех 9X_validate вещей потребует больших усилий. Вместо этого 9X_form-validation вы можете использовать пакет pyIsEmail.

Текст ниже 9X_validate взят с веб-сайта pyIsEmail.

pyIsEmail - серьезный 9X_string-parsing подход к проверке подлинности указанного 9X_email-validation пользователем адреса электронной почты.

Регулярные 9X_regular-expression выражения дешевы в написании, но часто требуют 9X_string-parsing обслуживания, когда появляются новые домены 9X_form-validation верхнего уровня или не соответствуют функциям 9X_mail адресации электронной почты, которые возвращаются 9X_validate в моду. pyIsEmail позволяет вам проверять 9X_string-parsing адрес электронной почты - и даже проверять 9X_form-validation домен, если хотите - одним простым вызовом, делая 9X_email-integration ваш код более читабельным и более быстрым 9X_form-validation для написания. Если вы хотите узнать, почему 9X_mail адрес электронной почты не подтверждается, вам 9X_regexp даже поставят диагноз.

Использование

Для простейшего использования 9X_email-integration импортируйте и используйте функцию is_email:

from pyisemail import is_email

address = "test@example.com"
bool_result = is_email(address)
detailed_result = is_email(address, diagnose=True)

Вы 9X_email-validation также можете проверить, является ли домен, использованный 9X_email-validation в электронном письме, допустимым доменом 9X_regular-expressions и имеет ли он действительную запись MX:

from pyisemail import is_email

address = "test@example.com"
bool_result_with_dns = is_email(address, check_dns=True)
detailed_result_with_dns = is_email(address, check_dns=True, diagnose=True)

Это 9X_regular-expressions основные индикаторы того, можно ли выдать 9X_email-validation адрес электронной почты в этом домене. Однако 9X_regular-expressions действительный ответ здесь не является гарантией 9X_regular-expression того, что электронное письмо существует, просто 9X_regular-expression оно может существовать.

В дополнение к базовой 9X_form-validation функциональности is_email вы также можете 9X_string-parsing использовать сами валидаторы. Проверьте 9X_email исходную документацию валидатора, чтобы 9X_form-validation узнать, как это работает.

2
0

Ответ #61

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Регулярное выражение, которое делает именно 9X_regexp то, что разрешено в стандартах, в соответствии 9X_validate с тем, что я видел о них, это следующее:

/^(?!(^[.-].*|.*[.-]@|.*\.{2,}.*)|^.{254}.+@)([a-z\xC0-\xFF0-9!#$%&'*+\/=?^_`{|}~.-]+@)(?!.{253}.+$)((?!-.*|.*-\.)([a-z0-9-]{1,63}\.)+[a-z]{2,63}|(([01]?[0-9]{2}|2([0-4][0-9]|5[0-5])|[0-9])\.){3}([01]?[0-9]{2}|2([0-4][0-9]|5[0-5])|[0-9]))$/gim

Demo / Debuggex analysis (interactive)

Разделение:

^(?!(^[.-].*|.*[.-]@|.*\.{2,}.*)|^.{254}.+@)
([a-z\xC0-\xFF0-9!#$%&'*+\/=?^_`{|}~.-]+@)
(?!.{253}.+$)
(
    (?!-.*|.*-\.)
    ([a-z0-9-]{1,63}\.)+
    [a-z]{2,63}
    |
    (([01]?[0-9]{2}|2([0-4][0-9]|5[0-5])|[0-9])\.){3}
    ([01]?[0-9]{2}|2([0-4][0-9]|5[0-5])|[0-9])
)$

Анализ:

(?!(^[.-].*|.*[.-]@|.*\.{2,}.*)|^.{254}.+@)

Отрицательный 9X_email-validation просмотр вперед для an address starting with a ., ending with one, having .. in it или превышающий the 254 character max length


([a-z\xC0-\xFF0-9!#$%&'*+\/=?^_`{|}~.-]+@)

соответствие 9X_email-validation 1 или более элементов permitted characters с применением к нему 9X_form-validation негативного вида


(?!.{253}.+$)

Отрицательный прогноз для 9X_regexp части имени домена, ограничивая его 253 characters in total


(?!-.*|.*-\.)

Отрицательный 9X_regular-expressions просмотр вперед для каждого из доменных 9X_email имен, использование которых запрещено starting or ending with .


([a-z0-9-]{1,63}\.)+

простое 9X_email-validation групповое соответствие разрешенных символов 9X_mail в имени домена, которые ограничены 63 characters each


[a-zA-Z]{2,63}

простое 9X_validation групповое совпадение для разрешенного домена 9X_email верхнего уровня, который в настоящее время 9X_form-validation still ограничен только буквами, но does include >4 letter TLDs.


(([01]?[0-9]{2}|2([0-4][0-9]|5[0-5])|[0-9])\.){3}
([01]?[0-9]{2}|2([0-4][0-9]|5[0-5])|[0-9])

альтернатива 9X_validation для доменных имен: это соответствует первым 9X_email-validation 3 числам в IP-адресе с . позади него, а затем 9X_form-validation четвертому числу в IP-адресе без . позади 9X_regexp него.

2
1

  • Не используйте это. Он отклонит международные домены, такие как «öåüñ». https://blog.cloudflare.com/non-latinutf8 ...

Ответ #62

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

У меня было аналогичное желание: я хотел 9X_email-validation быстро проверить синтаксис адресов электронной 9X_validate почты, не переусердствуя (ответ Mail::RFC822::Address, который, очевидно, является 9X_regexp правильным) для an eMail send utility. Я пошел с этим (я человек 9X_email-integration POSIX RE, поэтому я обычно не использую 9X_validate \d и тому подобное из PCRE, поскольку они 9X_regular-expression делают вещи менее читаемыми для меня):

preg_match("_^[-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*@[0-9A-Za-z]([-0-9A-Za-z]{0,61}[0-9A-Za-z])?(\.[0-9A-Za-z]([-0-9A-Za-z]{0,61}[0-9A-Za-z])?)*\$_", $adr)

Это 9X_regular-expression правильно RFC, но явно исключает устаревшие 9X_mail формы, а также прямые IP-адреса (IP и Legacy 9X_validation IP оба), которые кто-то из целевой группы 9X_string-parsing этой утилиты (в основном: люди, которые 9X_email-validation беспокоят нас в #sendmail в IRC) могут в 9X_regular-expression любом случае обычно не хочу и не нуждаюсь.

IDN 9X_email-validation (интернационализированные доменные имена) явно 9X_regular-expressions не в сфере электронной почты: такие адреса, как 9X_email-integration «foo@cäcilienchor-bonn.de» должны быть написаны 9X_form-validation «foo @ xn» --ccilienchor-bonn-vnb.de »в 9X_validate сети (сюда входят ссылки mailto: в HTML 9X_email-validation и тому подобное), только графическому интерфейсу 9X_email-integration разрешено отображать (и принимать, а затем 9X_regex преобразовывать) такие имена для пользователя 9X_regexp (и от него).

2
0

Ответ #63

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Стоило отметить, что чуть не был добавлен 9X_validate новый домен «яндекс». Возможные адреса электронной 9X_string-parsing почты: test@job.yandex. А также поддерживаются 9X_string-parsing прописные буквы, поэтому немного измененная 9X_form-validation версия решения acrosman:

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

2
1

  • Это слишком ограничительно и запрещает действительные адреса электронной почты, такие как `o'hare @ exa ...

Ответ #64

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Я нашел nice article, в котором говорится, что лучший 9X_email способ проверить адрес электронной почты 9X_validation - это регулярное выражение /.+@.+\..+/i.

1
2

  • Он также сопоставляет недопустимые адреса, такие ...

Ответ #65

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Самая популярная в мире платформа для ведения 9X_regexp блогов WordPress использует эту функцию для проверки 9X_validation адреса электронной почты.

Но они делают это 9X_email-integration в несколько этапов.

Вам больше не о чем беспокоиться 9X_validation при использовании регулярного выражения, упомянутого 9X_email-integration в этой функции.

Вот функция ..

/**
 * Verifies that an email is valid.
 *
 * Does not grok i18n domains. Not RFC compliant.
 *
 * @since 0.71
 *
 * @param string $email Email address to verify.
 * @param boolean $deprecated Deprecated.
 * @return string|bool Either false or the valid email address.
 */
function is_email( $email, $deprecated = false ) {
    if ( ! empty( $deprecated ) )
        _deprecated_argument( __FUNCTION__, '3.0' );

    // Test for the minimum length the email can be
    if ( strlen( $email ) < 3 ) {
        return apply_filters( 'is_email', false, $email, 'email_too_short' );
    }

    // Test for an @ character after the first position
    if ( strpos( $email, '@', 1 ) === false ) {
        return apply_filters( 'is_email', false, $email, 'email_no_at' );
    }

    // Split out the local and domain parts
    list( $local, $domain ) = explode( '@', $email, 2 );

    // LOCAL PART
    // Test for invalid characters
    if ( !preg_match( '/^[a-zA-Z0-9!#$%&\'*+\/=?^_`{|}~\.-]+$/', $local ) ) {
        return apply_filters( 'is_email', false, $email, 'local_invalid_chars' );
    }

    // DOMAIN PART
    // Test for sequences of periods
    if ( preg_match( '/\.{2,}/', $domain ) ) {
        return apply_filters( 'is_email', false, $email, 'domain_period_sequence' );
    }

    // Test for leading and trailing periods and whitespace
    if ( trim( $domain, " \t\n\r\0\x0B." ) !== $domain ) {
        return apply_filters( 'is_email', false, $email, 'domain_period_limits' );
    }

    // Split the domain into subs
    $subs = explode( '.', $domain );

    // Assume the domain will have at least two subs
    if ( 2 > count( $subs ) ) {
        return apply_filters( 'is_email', false, $email, 'domain_no_periods' );
    }

    // Loop through each sub
    foreach ( $subs as $sub ) {
        // Test for leading and trailing hyphens and whitespace
        if ( trim( $sub, " \t\n\r\0\x0B-" ) !== $sub ) {
            return apply_filters( 'is_email', false, $email, 'sub_hyphen_limits' );
        }

        // Test for invalid characters
        if ( !preg_match('/^[a-z0-9-]+$/i', $sub ) ) {
            return apply_filters( 'is_email', false, $email, 'sub_invalid_chars' );
        }
    }

    // Congratulations your email made it!
    return apply_filters( 'is_email', $email, $email, null );
}

1
0

Ответ #66

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Я преобразовал код в Java, чтобы он соответствовал 9X_form-validation компилятору

String pattern ="(?:[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*|\"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*\")@(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?|\\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])|[a-zA-Z0-9-]*[a-zA-Z0-9]:(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21-\\x5a\\x53-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])+)\\])";

1
0

Ответ #67

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Я хотел бы предложить свой подход, который 9X_regular-expressions является относительно простым, обеспечивая 9X_regular-expression правильную структуру электронной почты и 9X_regex ограничивая запрещенные символы. Действительно 9X_regular-expression для латинских символов.

/^(?![\w\.@]*\.\.)(?![\w\.@]*\.@)(?![\w\.]*@\.)\w+[\w\.]*@[\w\.]+\.\w{2,}$/

1
0

Ответ #68

Ответ на вопрос: Как я могу проверить адрес электронной почты с помощью регулярного выражения?

Как уже упоминалось, вы не можете проверить 9X_form-validation электронную почту с помощью регулярного 9X_validation выражения. Однако вот что мы в настоящее 9X_validate время используем, чтобы убедиться, что ввод 9X_email данных пользователем не является полностью 9X_validate ложным (забывая о TLD и т. Д.).

Это регулярное 9X_regexp выражение позволяет использовать домены 9X_regular-expression IDN и специальные символы (например, умляуты) до 9X_regex и после знака @.

/^[\w.+-_]+@[^.][\w.-]*\.[\w-]{2,63}$/iu

1
0