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

Question

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

Answer 1

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

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").bind("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>

Answer 2

Я немного изменил ответ Джеймона для людей, которым нужна действительно простая проверка в виде:

[e-mail]

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

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

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

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

Answer 3

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

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

[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

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

_{Акцент мой}

Answer 4

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

^\S+@\S+$

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

Answer 5

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

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

Answer 6

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

<form><input type="email" placeholder="[e-mail]">
    <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.!#$%&'*+/=?^_`{|}~-]+@[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])?)*$/

Answer 7

Я нашел это, чтобы быть лучшим решением:

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

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

1. [e-mail]
2. [e-mail]
3. одноразовый.стиль[e-mail]
4.  [e-mail]
9.  #!$%&'*+-/=?^_`∈ углем|~@example.org
6.  "()[]:,;@\\\"!#$%&'*+-/=?^_`{}| ~.A "@example.org
7.  " "@example.org (пробел между кавычками)
8.  üñîçøðé@example.com (символы Юникода в локальной части)
9.  üñîçøðé@üñîçøðé.com (символы Юникода в доменной части)
10. Pelé@example.com (латиница)
11. δοκιμή@παράδειγμα.δοκιμή (греческий)
12. 買 買@屋企.香港 (китайский)
13. 斐 斐@黒川.日本 (японский)
14. чебурашка@ящик-с-апельсинами.рф (кириллица)

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

Answer 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() : /\S+@\S+\.\S+/.test(value);
}

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

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)>)$

Answer 10

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

email.indexOf("@") > 0

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

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

Answer 11

Корректная проверка адреса электронной почты в соответствии с 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: Перед последней точкой должно быть не менее трех символов, например [e-mail],

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

Answer 12

Это правильная версия 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);
}

Answer 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;}

Answer 14

Сделай это:

[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('[e-mail]') );

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

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

Answer 15

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

• оригинал
  /^(([^<>()\[\]\\.,;:\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,})$/

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

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

Answer 16

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

<input type="email"/>

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

Answer 17

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

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

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

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

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

Answer 18

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

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

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

// VALID MAILS

validMail('[e-mail]') // Return true
validMail('[e-mail].') // Return true
validMail('Abc@10.42.0.1') // Return true
validMail('user@localserver') // Return true
validMail('[e-mail]') // Return true
validMail('user+mailbox/department=[e-mail]') // 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@[e-mail]') // Return false
validMail('a"b(c)d,e:f;g<h>i[j\k][e-mail]') // Return false
validMail('just"not"[e-mail]') // Return false
validMail('this is"not\[e-mail]') // Return false
validMail('this\ still\"not\\[e-mail]') // Return false
validMail('[e-mail]') // Return false
validMail('john.doe@example..com') // Return false

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

Answer 19

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

let val = '[e-mail]';
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

Answer 20

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

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

Вместо нового RegExpпопробуйте написать regexp вот так:

if (reg.test(/@/))

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

Answer 21

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

/^(?:[\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])\]))$/

Answer 22

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

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

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

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

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

Answer 23

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

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
}

Answer 24

<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>

Answer 25

В отличие от 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('[e-mail]')){ console.log('This is email is valid'); }

Answer 26

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

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

function check_email(val){
    if(!val.match(/\S+@\S+\.\S+/)){ // Jaymon's / Squirtle's 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(' [e-mail]'); // Returns false
check_email('[e-mail]'); // Returns true

Answer 27

Лучшее регулярное выражение, которое подтверждается 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])+

Answer 28

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

Вот текущее верхнее выражение, совместимое с 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

Answer 29

Видимо, вот и все:

/^([\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 октября 2010 года.

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

Answer 30

Я искал Regex в JS, который проходит все тестовые случаи адреса электронной почты:

• [e-mail] Правильный электронный адрес

• [e-mail] Письмо содержит точку в поле адреса

• [e-mail] Письмо содержит точку с поддоменом

• [e-mail] Знак плюс считается действительным символом

• email@192.0.2.123 Домен является действительным IP-адресом

• email@[192.0.2.123] Квадратная скобка вокруг IP-адреса считается действительной

• “email”@example.com Цитаты по электронной почте считаются действительными

• [e-mail] Цифры в адресе действительны

• [e-mail] Тире в доменном имени действительна

• [e-mail] Подчеркивание в поле адреса является действительным

• [e-mail] является допустимым доменным именем верхнего уровня

• [e-mail] Точка в домене верхнего уровня также считается действительной (с использованием co.jp как пример тут)

• [e-mail] Тире в поле адреса действительна

Вот так:

http://regexr.com/3f07j

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

Regex = /(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@[*[a-zA-Z0-9-]+.[a-zA-Z0-9-.]+]*/