Как проверить адрес электронной почты в JavaScript

Ответ 1

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

function validateEmail(email) {
    var re = /^(([^<>()\[\]\\.,;:\[email protected]"]+(\.[^<>()\[\]\\.,;:\[email protected]"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
    return re.test(String(email).toLowerCase());
}

Вот пример регулярного выражения, принимающего Unicode:

var re = /^(([^<>()\[\]\.,;:\[email protected]\"]+(\.[^<>()\[\]\.,;:\[email protected]\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\[email protected]\"]+\.)+[^<>()[\]\.,;:\[email protected]\"]{2,})$/i;

Но имейте в виду, что не следует полагаться только на валидацию JavaScript. JavaScript можно легко отключить. Это должно быть проверено и на стороне сервера.

Вот пример вышесказанного в действии:

function validateEmail(email) {
  var re = /^(([^<>()[\]\\.,;:\[email protected]\"]+(\.[^<>()[\]\\.,;:\[email protected]\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
  return re.test(email);
}

function validate() {
  var $result = $("#result");
  var email = $("#email").val();
  $result.text("");

  if (validateEmail(email)) {
    $result.text(email + " is valid :)");
    $result.css("color", "green");
  } else {
    $result.text(email + " is not valid :(");
    $result.css("color", "red");
  }
  return false;
}

$("#validate").on("click", validate);

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

<form>
  <p>Enter an email address:</p>
  <input id='email'>
  <button type='submit' id='validate'>Validate!</button>
</form>

<h2 id='result'></h2>

Ответ 2

Просто для полноты, здесь у вас есть еще одно регулярное выражение RFC 2822

Официальный стандарт известен как RFC 2822. В нем описывается синтаксис, которому должны соответствовать действительные адреса электронной почты. Вы можете (, но вы не должны — читать) реализовать его с помощью этого регулярного выражения:

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

(...) Мы получим более практическую реализацию RFC 2822, если мы опустим синтаксис, используя двойные кавычки и квадратные скобки. Он по-прежнему будет соответствовать 99,99% всех адресов электронной почты, используемых в настоящее время.

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

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

[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+(?:[A-Z]{2}|com|org|net|gov|mil|biz|info|mobi|name|aero|jobs|museum)\b

Таким образом, даже при соблюдении официальных стандартов, все еще существуют компромиссы. Не слепо копировать регулярные выражения из онлайновых библиотек или дискуссионных форумов. Всегда проверяйте их на своих собственных данных и своими собственными приложениями.

_{Акцент на мине}

Ответ 3

Я немного изменил ответ Jaymon для людей, которые хотят действительно простой проверки в форме:

[email protected]

Регулярное выражение:

/\[email protected]\S+\.\S+/

Пример функции JavaScript:

function validateEmail(email) 
{
    var re = /\[email protected]\S+\.\S+/;
    return re.test(email);
}

Ответ 4

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

^\[email protected]\S+$

Обычно он улавливает наиболее очевидные ошибки, которые совершает пользователь, и заверяет, что форма в основном правильная, что и является целью проверки JavaScript.

Ответ 5

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

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

Ответ 6

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

<form><input type="email" placeholder="[email protected]" required>
    <input type="submit">
</form>

ссылка jsFiddle

Из спецификации HTML5:

Допустимый адрес электронной почты - это строка, которая соответствует производству email следующего ABNF, набор символов для которого - Unicode.

email   = 1*( atext / "." ) "@" label *( "." label )
label   = let-dig [ [ ldh-str ] let-dig ]  ; limited to a length of 63 characters by RFC 1034 section 3.5
atext   = < as defined in RFC 5322 section 3.2.3 >
let-dig = < as defined in RFC 1034 section 3.5 >
ldh-str = < as defined in RFC 1034 section 3.5 >

Это требование является преднамеренным нарушением RFC 5322, который определяет синтаксис для адресов электронной почты, который является одновременно слишком строгим (до символа "@"), слишком расплывчатым (после символа "@") и слишком слабым (допускает комментарии, пробельные символы и строки в кавычках способами, незнакомыми большинству пользователей) для практического использования здесь.

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

/^[a-zA-Z0-9.!#$%&'*+/=?^_'{|}~-][email protected][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])?)*$/

Ответ 7

Я нашел это лучшим решением:

/^[^\[email protected]][email protected][^\[email protected]]+\.[^\[email protected]]+$/

Он позволяет использовать следующие форматы:

1.  [email protected]
2.  [email protected]
3.  [email protected]
4.  [email protected]
9.  #!$%&'*+-/=?^_`{}|[email protected]
6.  "()[]:,;@\\\"!#$%&'*+-/=?^_`{}| ~.a"@example.org
7.  " "@example.org (space between the quotes)
8.  üñîçøðé@example.com (Unicode characters in local part)
9.  üñîçøðé@üñîçøðé.com (Unicode characters in domain part)
10. Pelé@example.com (Latin)
11. δοκιμή@παράδειγμα.δοκιμή (Greek)
12. 我買@屋企.香港 (Chinese)
13. 甲斐@黒川.日本 (Japanese)
14. чебурашка@ящик-с-апельсинами.рф (Cyrillic)

Он явно универсален и позволяет использовать все важные международные символы, сохраняя при этом базовый формат [email protected] Он блокирует пробелы, которые технически разрешены RFC, но они настолько редки, что я счастлив сделать это.

Ответ 8

В современных браузерах вы можете использовать ответ @Sushil, используя чистый JavaScript и DOM:

function validateEmail(value) {
  var input = document.createElement('input');

  input.type = 'email';
  input.required = true;
  input.value = value;

  return typeof input.checkValidity === 'function' ? input.checkValidity() : /\[email protected]\S+\.\S+/.test(value);
}

Я собрал пример в скрипке http://jsfiddle.net/boldewyn/2b6d5/. В сочетании с обнаружением функций и простой проверкой из Squirtle Answer он освобождает вас от расправы с регулярными выражениями и не работает в старых браузерах.

Ответ 9

JavaScript может соответствовать регулярному выражению:

emailAddress.match( / some_regex /);

Здесь RFC22 регулярное выражение для писем:

^((?>[a-zA-Z\d!#$%&'*+\-/=?^_`{|}~]+\x20*|"((?=[\x01-\x7f])[^"\\]|\\[\x01-\x7f])*
"\x20*)*(?<angle><))?((?!\.)(?>\.?[a-zA-Z\d!#$%&'*+\-/=?^_`{|}~]+)+|"((?=[\x01-\x
7f])[^"\\]|\\[\x01-\x7f])*")@(((?!-)[a-zA-Z\d\-]+(?<!-)\.)+[a-zA-Z]{2,}|\[(((?(?<
!\[)\.)(25[0-5]|2[0-4]\d|[01]?\d?\d)){4}|[a-zA-Z\d\-]*[a-zA-Z\d]:((?=[\x01-\x7f])
[^\\\[\]]|\\[\x01-\x7f])+)\])(?(angle)>)$

Ответ 10

Это правильная версия RFC822.

function checkEmail(emailAddress) {
  var sQtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]';
  var sDtext = '[^\\x0d\\x5b-\\x5d\\x80-\\xff]';
  var sAtom = '[^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-\\x3c\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+';
  var sQuotedPair = '\\x5c[\\x00-\\x7f]';
  var sDomainLiteral = '\\x5b(' + sDtext + '|' + sQuotedPair + ')*\\x5d';
  var sQuotedString = '\\x22(' + sQtext + '|' + sQuotedPair + ')*\\x22';
  var sDomain_ref = sAtom;
  var sSubDomain = '(' + sDomain_ref + '|' + sDomainLiteral + ')';
  var sWord = '(' + sAtom + '|' + sQuotedString + ')';
  var sDomain = sSubDomain + '(\\x2e' + sSubDomain + ')*';
  var sLocalPart = sWord + '(\\x2e' + sWord + ')*';
  var sAddrSpec = sLocalPart + '\\x40' + sDomain; // complete RFC822 email address spec
  var sValidEmail = '^' + sAddrSpec + '$'; // as whole string

  var reValidEmail = new RegExp(sValidEmail);

  return reValidEmail.test(emailAddress);
}

Ответ 11

Все адреса электронной почты содержат символ "at" (то есть @). Проверьте это необходимое условие:

email.indexOf("@") > 0

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

Чтобы проверить это, отправьте сообщение проверки.

Ответ 12

Корректная проверка адреса электронной почты в соответствии с RFC не может быть достигнута с помощью регулярного выражения, состоящего из одной строки. Статья с лучшим решением, которое я нашел в PHP - Что такое действующий адрес электронной почты?. Очевидно, он был портирован на Java. Я думаю, что функция слишком сложна для переноса и использования в JavaScript. Порт JavaScript/node.js: https://www.npmjs.com/package/email-addresses.

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

Вот функция JavaScript, которую я использую, чтобы проверить, похожа ли строка на действительный почтовый адрес:

function looksLikeMail(str) {
    var lastAtPos = str.lastIndexOf('@');
    var lastDotPos = str.lastIndexOf('.');
    return (lastAtPos < lastDotPos && lastAtPos > 0 && str.indexOf('@@') == -1 && lastDotPos > 2 && (str.length - lastDotPos) > 2);
}

Объяснение:

• lastAtPos < lastDotPos: последний @ должен предшествовать последнему ., поскольку @ не может быть частью имени сервера (насколько я знаю).

• lastAtPos > 0: перед последним @ должно быть что-то (имя пользователя электронной почты).

• str.indexOf('@@') == -1: в адресе не должно быть @@. Даже если @ появляется как последний символ в имени пользователя электронной почты, его нужно заключить в кавычки, чтобы " находился между этим @ и последним @ в адресе.

• lastDotPos > 2: перед последней точкой должно быть не менее трех символов, например [email protected].

• (str.length - lastDotPos) > 2: После последней точки должно быть достаточно символов, чтобы сформировать двухсимвольный домен. Я не уверен, что скобки необходимы.

Ответ 13

Это было украдено из http://codesnippets.joyent.com/posts/show/1917

email = $('email');
filter = /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/;
if (filter.test(email.value)) {
  // Yay! valid
  return true;
}
else
  {return false;}

Ответ 14

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

• Оригинальный
  /^(([^<>()\[\]\\.,;:\[email protected]"]+(\.[^<>()\[\]\\.,;:\[email protected]"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/

• Модифицированный
  /^(([^<>()\[\]\.,;:\[email protected]\"]+(\.[^<>()\[\]\.,;:\[email protected]\"]+)*)|(\".+\"))@(([^<>()\.,;\[email protected]\"]+\.{0,1})+[^<>()\.,;:\[email protected]\"]{2,})$/

чтобы передать примеры в Адрес электронной почты Википедии.

И вы можете увидеть результат здесь.

Ответ 15

Сделай это:

[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])?

Зачем? Это основано на RFC 2822, который является стандартным, ВСЕ адреса электронной почты ДОЛЖНЫ придерживаться. И я не уверен, почему вы возитесь с чем-то "более простым"... вы все равно скопируете и вставите его;)

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

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

Вот пример его использования в JavaScript (с нечувствительным к регистру флагом i в конце).

var emailCheck=/^[a-z0-9!#$%&'*+/=?^_'{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_'{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i;
console.log( emailCheck.test('[email protected]') );

Примечание:
Технически, некоторые электронные письма могут содержать кавычки в разделе перед символом @ с escape-символами внутри кавычек (так что ваш пользователь электронной почты может быть противным и содержать такие вещи, как @ и "..." если он написан в кавычках). ЭТО НИКОГДА НЕ ДЕЛАЕТ! Это устарело. Но он включен в настоящий стандарт RFC 2822 и здесь опущен.

Дополнительная информация: http://www.regular-expressions.info/email.html

Ответ 16

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

Теперь, поскольку вы можете покрывать только 90% случаев, напишите что-нибудь вроде:

function isPossiblyValidEmail(txt) {
   return txt.length > 5 && txt.indexOf('@')>0;
}

Вы можете уточнить его. Например, "aaa @" действителен. Но в целом вы получаете суть. И не увлекайтесь... Простое 90% -ное решение лучше, чем 100% -ное решение, которое не работает.

Мир нуждается в более простом коде...

Ответ 17

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

<input type="email"/>

Нет необходимости писать функцию для проверки.

Ответ 18

Вот как это делает узел-валидатор:

/^(?:[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\'\{\|\}\~]+\.)*[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\'\{\|\}\~][email protected](?:(?:(?:[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]?)|(?:\[(?:(?:[01]?\d{1,2}|2[0-4]\d|25[0-5])\.){3}(?:[01]?\d{1,2}|2[0-4]\d|25[0-5])\]))$/

Ответ 19

Трудно получить валидатор электронной почты на 100% правильно. Единственный реальный способ исправить это - отправить тестовое электронное письмо на аккаунт. Тем не менее, есть несколько основных проверок, которые помогут убедиться, что вы получаете что-то разумное.

Некоторые вещи для улучшения:

Вместо нового RegExp просто попробуйте написать regexp следующим образом:

if (reg.test(/@/))

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

Ответ 20

Используйте этот код внутри вашей функции валидатора:

var emailID = document.forms["formName"]["form element id"].value;
atpos = emailID.indexOf("@");
dotpos = emailID.lastIndexOf(".");
if (atpos < 1 || ( dotpos - atpos < 2 ))
{
    alert("Please enter correct email ID")
    return false;
}

Еще вы можете использовать JQuery. Внутренние правила определяют:

eMailId: {
    required: true,
    email: true
}

Ответ 21

В отличие от squirtle, вот комплексное решение, но он отлично справляется с правильной проверкой писем:

function isEmail(email) { 
    return /^((([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.test(email);
} 

Используйте так:

if (isEmail('[email protected]')){ console.log('This is email is valid'); }

Ответ 22

Regex для проверки адреса электронной почты

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

Ответ 23

Решение, которое не проверяет существование TLD, является неполным.

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

1- Проверка формата электронной почты: Убедитесь, что электронная почта соответствует формату и шаблону электронных писем в RFC 5322 и действительно ли существует TLD. Список всех действующих TLD можно найти здесь.

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

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

Ответ 24

Regex обновление 2018 года! попробуй это

let val = '[email protected]';
if(/^[a-z0-9][a-z0-9-_\.][email protected]([a-z]|[a-z0-9]?[a-z0-9-]+[a-z0-9])\.[a-z0-9]{2,10}(?:\.[a-z]{2,10})?$/.test(val)) {
   console.log('passed');
}

полная версия

//
export const emailValid = (val:string):boolean => /^[a-z0-9][a-z0-9-_\.][email protected]([a-z]|[a-z0-9]?[a-z0-9-]+[a-z0-9])\.[a-z0-9]{2,10}(?:\.[a-z]{2,10})?$/.test(val);

больше информации https://git.io/vhEfc

Ответ 25

По-видимому, это:

/^([\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+\.)*[\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~][email protected]((((([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

Взято из http://fightingforalostcause.net/misc/2006/compare-email-regex.php с 1 октября '10.

Но, конечно, это игнорирование интернационализации.

Ответ 26

Вот очень хорошая дискуссия об использовании регулярных выражений для проверки адресов электронной почты; " Сравнение адреса электронной почты с проверкой регулярных выражений

Вот текущее верхнее выражение, совместимое с JavaScript, для справочных целей:

/^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+)*\.(aero|arpa|biz|com|coop|edu|gov|info|int|mil|museum|name|net|org|pro|travel|mobi|[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i

Ответ 27

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

Наиболее распространенные ошибки, с которыми я сталкиваюсь, - это пробелы (особенно в начале и в конце) и иногда двойная точка.

function check_email(val){
    if(!val.match(/\[email protected]\S+\.\S+/)){ // Jaymon / Squirtle solution
        // Do something
        return false;
    }
    if( val.indexOf(' ')!=-1 || val.indexOf('..')!=-1){
        // Do something
        return false;
    }
    return true;
}

check_email('[email protected]'); // Returns false
check_email('[email protected]'); // Returns false
check_email(' [email protected]'); // Returns false
check_email('[email protected]'); // Returns true

Ответ 28

<form name="validation" onSubmit="return checkbae()">
    Please input a valid email address:<br />

    <input type="text" size=18 name="emailcheck">
    <input type="submit" value="Submit">
</form>

<script language="JavaScript1.2">
    var testresults
    function checkemail(){
        var str = document.validation.emailcheck.value
        var filter = /^([\w-]+(?:\.[\w-]+)*)@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$/i
        if (filter.test(str))
            testresults = true
        else {
            alert("Please input a valid email address!")
            testresults = false
        }
        return (testresults)
    }
</script>

<script>
    function checkbae(){
        if (document.layers || document.getElementById || document.all)
            return checkemail()
        else
            return true
    }
</script>

Ответ 29

Регулярное выражение, предоставляемое Microsoft в ASP.NET MVC:

/^[\w-]+(\.[\w-]+)*@([a-z0-9-]+(\.[a-z0-9-]+)*?\.[a-z]{2,6}|(\d{1,3}\.){3}\d{1,3})(:\d{4})?$/

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

Ответ 30

Википедия стандартный почтовый синтаксис:

https://en.wikipedia.org/wiki/Email_address#Examples https://fr.wikipedia.org/wiki/Adresse_%C3%A9lectronique#Syntaxe_exacte

function validMail(mail)
{
    return /^(([^<>()\[\]\.,;:\[email protected]\"]+(\.[^<>()\[\]\.,;:\[email protected]\"]+)*)|(\".+\"))@(([^<>()\.,;\[email protected]\"]+\.{0,1})+([^<>()\.,;:\[email protected]\"]{2,}|[\d\.]+))$/.test(mail);
}

// VALID MAILS

validMail('[email protected]') // Return true
validMail('[email protected]') // Return true
validMail('[email protected]') // Return true
validMail('[email protected]') // Return true
validMail('[email protected]') // Return true
validMail('user+mailbox/[email protected]') // Return true
validMail('"very.(),:;<>[]\".VERY.\"[email protected]\\ \"very\".unusual"@strange.example.com') // Return true
validMail('!#$%&\'*+-/=?^_'.{|}[email protected]') // Return true
validMail('"()<>[]:,;@\\\"!#$%&\'-/=?^_'{}| ~.a"@example.org') // Return true
validMail('"[email protected]"@example.com') // Return true
validMail('"Fred Bloggs"@example.com') // Return true
validMail('"Joe.\\Blow"@example.com') // Return true
validMail('Loïc.Accentué@voilà.fr') // Return true
validMail('" "@example.org') // Return true
validMail('[email protected][IPv6:2001:DB8::1]') // Return true

// INVALID MAILS

validMail('Abc.example.com') // Return false
validMail('[email protected]@[email protected]') // Return false
validMail('a"b(c)d,e:f;g<h>i[j\k][email protected]') // Return false
validMail('just"not"[email protected]') // Return false
validMail('this is"not\[email protected]') // Return false
validMail('this\ still\"not\\[email protected]') // Return false
validMail('[email protected]') // Return false
validMail('[email protected]') // Return false

Показать этот тест: https://regex101.com/r/LHJ9gU/1