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

https://stackoverflow.com/questions/46155

09-06-2019
|

Вопрос

Как можно проверить адрес электронной почты в 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(String(email).toLowerCase());
}

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

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>

Другие советы

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

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

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

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

Anystring@anystring.anystring

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

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

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

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

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

^\S+@\S+$

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

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

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

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

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

jsFiddle связь

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

А Действующий электронный адрес это строка, соответствующая email создание следующего ABNF, набором символов которого является Unicode.
email   = 1*( atext / "." ) "@" label *( "." label )
label   = let-dig [ [ ldh-str ] let-dig ]  ; limited to a length of 63 characters by RFC 1034 section 3.5
atext   = < as defined in RFC 5322 section 3.2.3 >
let-dig = < as defined in RFC 1034 section 3.5 >
ldh-str = < as defined in RFC 1034 section 3.5 >
Это требование является умышленное нарушение RFC 5322, определяющий синтаксис адресов электронной почты, который одновременно является слишком строгим (перед символом «@»), слишком расплывчатым (после символа «@») и слишком нестрогим (допускаются комментарии, пробелы и кавычки). строки способами, незнакомыми большинству пользователей), чтобы иметь здесь практическое применение.

Следующее регулярное выражение, совместимое с JavaScript и Perl, является реализацией приведенного выше определения.
/^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[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])?)*$/

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

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

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

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

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

email.indexOf("@") > 0

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

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

Правильная проверка адреса электронной почты в соответствии с 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:Перед последней точкой должно быть не менее трех символов, например a@b.com.
(str.length - lastDotPos) > 2:После последней точки должно быть достаточно символов, чтобы образовался двухсимвольный домен.Я не уверен, что скобки необходимы.

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

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

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

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

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

Сделай это:

[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

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

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

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

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

Миру нужен более простой код...

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

<input type="email"/>

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

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

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

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

Некоторые вещи, которые нужно улучшить:

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

if (reg.test(/@/))

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

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

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
}

Обновление регулярного выражения 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

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

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

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

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

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

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

Судя по всему, вот оно:

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

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

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

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

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

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

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

Регулярное выражение, предоставленное Microsoft в рамках АСП.NET MVC является

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

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

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

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

Лицензировано под: CC-BY-SA с атрибуция

Не связан с StackOverflow