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

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

3729
05 сент. '08 в 19:10
источник поделиться
83 ответов
  • 1
  • 2
  • 3

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

function validateEmail(email) {
    var re = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[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 = /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;

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

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

function validateEmail(email) {
  var re = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[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>
4266
05 сент. '08 в 19:15
источник

Просто для полноты, здесь у вас есть еще одно регулярное выражение 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])?

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

[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

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

Акцент на мине

683
03 сент. '09 в 17:26
источник

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

anystring@anystring.anystring

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

/\S+@\S+\.\S+/

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

function validateEmail(email) 
{
    var re = /\S+@\S+\.\S+/;
    return re.test(email);
}
645
09 февр. '12 в 5:22
источник

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

^\S+@\S+$

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

325
08 сент. '08 в 0:21
источник

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

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

314
02 мая '09 в 20:18
источник

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

<form><input type="email" placeholder="me@example.com">
    <input type="submit">
</form>

jsFiddle ссылка

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

A действительный адрес электронной почты - это строка, соответствующая типу 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.!#$%&'*+/=?^_`{|}~-]+@[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])?)*$/
181
17 окт. '11 в 11:23
источник

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

/^[^\s@]+@[^\s@]+\.[^\s@]+$/

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

1.  prettyandsimple@example.com
2.  very.common@example.com
3.  disposable.style.email.with+symbol@example.com
4.  other.email-with-dash@example.com
9.  #!$%&'*+-/=?^_`{}|~@example.org
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)

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

112
21 сент. '15 в 4:52
источник

В современных браузерах вы можете использовать ответ @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() : /\S+@\S+\.\S+/.test(value);
}

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

87
20 дек. '12 в 18:20
источник

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)>)$
66
05 сент. '08 в 19:13
источник

Это правильная версия 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);
}
62
15 апр. '13 в 16:31
источник

Корректная проверка адреса электронной почты в соответствии с 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: Last @ должен быть перед последним . поскольку @ не может быть частью имени сервера (насколько я знаю).

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

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

  • lastDotPos > 2: перед последней точкой должно быть не менее трех символов, например a@b.com.

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

51
02 марта '11 в 14:26
источник

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

email.indexOf("@") > 0

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

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

50
14 июля '13 в 21:15
источник

Это было украдено из 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;}
41
02 мая '09 в 20:19
источник

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

  • Оригинальный
    /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[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,}))$/

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

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

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

введите описание изображения здесь

36
01 июля '16 в 7:43
источник

Сделай это:

[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('some.body@domain.co.uk') );

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

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

31
01 нояб. '12 в 17:06
источник

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

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

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

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

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

22
19 дек. '11 в 21:39
источник

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

<input type="email"/>

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

19
25 июня '13 в 9:30
источник

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

/^(?:[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\'\{\|\}\~]+\.)*[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\'\{\|\}\~]+@(?:(?:(?:[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])\]))$/
17
11 сент. '13 в 5:21
источник

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

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

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

if (reg.test(/@/))

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

15
02 мая '09 в 20:23
источник

Лучшее регулярное выражение, которое соответствует RFC5322

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

13
22 дек. '16 в 10:44
источник

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

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
}
13
29 нояб. '13 в 15:26
источник

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

let val = 'email@domain.com';
if(/^[a-z0-9][a-z0-9-_\.]+@([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-_\.]+@([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

12
06 февр. '18 в 23:42
источник

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

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

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

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

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

12
28 дек. '17 в 5:51
источник

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

/^([\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

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

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

11
01 окт. '10 в 12:37
источник

В отличие от 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('youremail@yourdomain.com')){ console.log('This is email is valid'); }
11
06 июня '12 в 2:41
источник

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

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

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

check_email('check@thiscom'); // Returns false
check_email('check@this..com'); // Returns false
check_email(' check@this.com'); // Returns false
check_email('check@this.com'); // Returns true
10
15 апр. '13 в 14:53
источник

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

Вот текущее верхнее выражение, совместимое с 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
10
29 мая '10 в 1:05
источник
<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>
9
31 янв. '13 в 12:39
источник

Регулярное выражение, предоставляемое 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})?$/

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

8
04 дек. '13 в 13:44
источник

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

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

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

// VALID MAILS

validMail('Abc@example.com') // Return true
validMail('Abc@example.com.') // Return true
validMail('Abc@10.42.0.1') // Return true
validMail('user@localserver') // Return true
validMail('Abc.123@example.com') // Return true
validMail('user+mailbox/department=shipping@example.com') // Return true
validMail('"very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"@strange.example.com') // Return true
validMail('!#$%&\'*+-/=?^_'.{|}~@example.com') // Return true
validMail('"()<>[]:,;@\\\"!#$%&\'-/=?^_'{}| ~.a"@example.org') // Return true
validMail('"Abc@def"@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('user@[IPv6:2001:DB8::1]') // Return true

// INVALID MAILS

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

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

8
21 июня '17 в 12:10
источник
  • 1
  • 2
  • 3

Посмотрите другие вопросы по меткам или Задайте вопрос