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

Question

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

3393

email email-validation javascript regex validation

автор: pix0r

30 ответов

автор: rnevius · Accepted Answer · 2018-03-16 21:33:25

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

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>

автор: voyager · Accepted Answer · 2014-06-20 00:24:14

просто для полноты, здесь у вас есть другой RFC 2822 совместимый regex

официальный стандарт известен как 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

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

_{выделено мной}

автор: Squirtle · Accepted Answer · 2018-08-14 23:30:48

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

anystring@anystring.anystring

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

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

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

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

автор: Paolo Bergantino · Accepted Answer · 2009-05-02 17:18:29

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

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

автор: Jaymon · Accepted Answer · 2013-08-24 20:44:38

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

\S+@\S+

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

автор: Anoop · Accepted Answer · 2016-01-07 15:06:53

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

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

jsFiddle ссылке

С HTML5 spec:

A действующий e-mail адрес - строка, которая соответствует 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 >
данное требование является злостное нарушение of 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])?)*$/

автор: Andrew · Accepted Answer · 2015-09-21 01:52:30

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

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

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

автор: Boldewyn · Accepted Answer · 2018-07-25 07:07:40

в современных браузерах вы можете построить поверх ответа @Sushil с помощью чистого JavaScript и дом:

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/. В сочетании с обнаружением функций и проверкой голых костей от ответ Сквиртл, он освобождает вас от регулярного выражения massacre и не Борк на старых браузерах.

автор: Ben Scheirman · Accepted Answer · 2013-08-24 20:45:54

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

автор: bvl · Accepted Answer · 2015-02-25 15:18:50

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

автор: Miloš Rašić · Accepted Answer · 2014-06-05 08:40:22

правильная проверка адреса электронной почты в соответствии с RFCs не является чем-то, что может быть достигнуто с помощью однострочного регулярного выражения. Статья лучшее решение я нашел в PHP что это действительный адрес электронной почты?. Очевидно, что он был портирован на Java. Я думаю, что функция слишком сложна для переноса и использования в JavaScript.

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

вот функция 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: после последней точки должно быть достаточно символов, чтобы сформировать двухсимвольный домен. Я не уверен, нужны ли скобки.

автор: Colonel Panic · Accepted Answer · 2018-04-15 10:22:07

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

email.indexOf("@") > 0

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

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

автор: Adam McKee · Accepted Answer · 2009-05-02 17:19:46

Это было украдено из 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;}

автор: Keith Lee · Accepted Answer · 2016-11-13 10:21: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,})$/

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

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

автор: Ryan Taylor · Accepted Answer · 2018-09-20 14:11:37

этого:

[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-символы внутри кавычек (так что ваш пользователь электронной почты может быть неприятным и содержать такие вещи, как @ и "..." пока это написано в кавычках). НИКТО НИКОГДА ТАК НЕ ДЕЛАЕТ! Она устарела. Но, это включено в true RFC 2822 стандартный и опущен здесь.

Подробнее: http://www.regular-expressions.info/email.html

автор: Zo72 · Accepted Answer · 2015-03-09 17:24:19

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

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

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

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

миру нужно проще код...

автор: Learner · Accepted Answer · 2014-03-14 16:30:43

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

<input type="email"/>

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

автор: pera · Accepted Answer · 2018-04-15 10:22:32

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

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

автор: jacobangel · Accepted Answer · 2018-04-15 10:15:03

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

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

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

if (reg.test(/@/))

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

автор: bman · Accepted Answer · 2018-07-02 01:47:08

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

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

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

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

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

автор: Félix Saparelli · Accepted Answer · 2010-10-01 09:37:31

видимо, вот это:

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

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

автор: steve · Accepted Answer · 2016-06-01 05:12:03

В отличие от 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'); }

автор: Orchid · Accepted Answer · 2018-04-15 10:23:17

использовать этот код внутри функции-валидатора:

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
}

автор: Prabhat Kasera · Accepted Answer · 2018-06-25 17:01:24

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

автор: Juan Pablo · Accepted Answer · 2018-08-07 14:08:39

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');
}

версия typscript завершена

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

автор: Eric Schoonover · Accepted Answer · 2010-05-28 22:05:45

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

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

автор: Linkmichiel · Accepted Answer · 2014-03-14 16:29:29

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

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

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(' check@this.com'); // Returns false
check_email('check@this.com'); // Returns true

автор: Tugrul Asik · Accepted Answer · 2014-06-05 09:05:36

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

автор: Liberateur · Accepted Answer · 2017-06-21 09:10:18

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

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

автор: Neil Thompson · Accepted Answer · 2014-07-12 02:59:07

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

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

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