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

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

30 ответов


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

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

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

еще одно изменение, которое вы можете сделать, - разрешить любой двухбуквенный домен верхнего уровня кода страны и только определенные общие домены верхнего уровня. это регулярное выражение фильтрует фиктивные адреса электронной почты, такие как [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

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

выделено мной


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

[email protected]

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

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

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

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

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

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


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

\[email protected]\S+

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


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

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

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

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

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


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

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


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

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

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

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


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

email.indexOf("@") > 0

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

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


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

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

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

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

enter image description here


этого:

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

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


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

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

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

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

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


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

<input type="email"/>

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


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

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

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

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

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

if (reg.test(/@/))

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


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

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

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

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

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


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

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

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


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

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

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
}

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


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

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

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


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

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

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

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

function check_email(val){
    if(!val.match(/\[email protected]\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('[email protected]'); // Returns false
check_email('[email protected]'); // Returns false
check_email(' [email protected]'); // Returns false
check_email('[email protected]'); // Returns true

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

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

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


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

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