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

3736

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

  • 0
    Ответы на вопросы Проверьте / расширите мое регулярное выражение электронной почты или Как далеко нужно пройти проверку адреса электронной почты? может быть легко адаптирован для JavaScript
  • 114
    Хотя это решение может быть простым, я уверен, что это одна из тех полезных вещей, которую люди будут искать в Google, и она заслуживает отдельной записи на сайте, если только Google будет первым местом для поиска :) Просто посмотрите на дубликаты это закрыто через некоторое время.
Показать ещё 10 комментариев
Теги:
validation
email
email-validation

79 ответов

3897
Лучший ответ

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

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>
  • 7
    Может ли кто-нибудь объяснить, с чем это будет и не будет совпадать? (Учитывая некоторые дополнительные ответы ниже.) Было бы неплохо узнать немного больше информации, чтобы определить, какое «решение» использовать для проекта.
  • 0
    +1: Единственное, что не пропустит это IP-адреса, а не домены. Он принимает домены, начинающиеся или заканчивающиеся дефисом, и домены длиной более 64 символов, но кроме этого он выполняет достаточно хорошую работу. Приветствия.
Показать ещё 80 комментариев
645

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

[email protected]

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

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

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

function validateEmail(email) 
{
    var re = /\S+@\S+\.\S+/;
    return re.test(email);
}
  • 69
    @neoascetic Shazam! /[^\s@]+@[^\s@]+\.[^\s@]+/.test('name@[email protected]') // false
  • 48
    Вы можете реализовать что-то в 20 раз дольше, что может вызвать проблемы у нескольких пользователей и может оказаться недействительным в будущем, или вы можете взять версию ImmortalFirefly, чтобы убедиться, что они хотя бы приложат усилия, чтобы это выглядело реальным. В зависимости от вашего приложения, это может привести к тому, что кто-то разозлится из-за того, что вы не принимаете их нетрадиционные электронные письма, вместо того, чтобы вызывать проблемы, вводя адреса электронной почты, которые на самом деле не существуют (что они могут сделать в любом случае, введя 100% действительный адрес электронной почты RFC2822, но с использованием незарегистрированного имени пользователя или домена). Upvoted!
Показать ещё 14 комментариев
630

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

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

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

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

  • 76
    NB: «На практике сегодня » может быть действительным, когда код был написан, еще в 200 раз. Код , вероятно, останется в использовании после этого конкретного года. (Если бы у меня было десять центов на каждое «ме, никто бы никогда не использовал TLD с 4 + буквами, кроме тех, которые мне нужно было исправить», я мог бы загнать в угол мировой рынок меди и никеля;))
  • 6
    Для практической реализации RFC 2822 окончание должно быть немного изменено, чтобы не допустить расширения одного домена символа. / [a-z0-9! # $% & '* + \ / =? ^ _ {|}~-]+(?:\.[a-z0-9!#$%&'*+\/=?^_ {|} ~ -] +) * @ (?: [a-z0-9] (?: [a-z0-9 -] * [a-z0-9])? \.) + [a -z0-9] [а-z0-9 -] * [а-z0-9] /
Показать ещё 11 комментариев
325

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

^\S+@\S+$

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

  • 61
    +1, так как отправка электронной почты и просмотр того, что происходит, - это единственный реальный надежный способ проверки адреса электронной почты, нет необходимости делать больше, чем простое совпадение с регулярным выражением.
  • 0
    Модифицированная версия Squirtle, представленная ниже, кажется наиболее эффективным решением на странице. Вы можете проверить все, что вы хотите, но я все еще могу ввести адрес электронной почты "@ gmaaaail.com".
Показать ещё 15 комментариев
323

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

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

  • 103
    -1 Зачем мне тратить время на проверку адреса электронной почты, который даже не проходит через регулярное выражение?
  • 0
    @PaoloBergantino Я имею в виду, почему я должен пытаться отправить письмо, чтобы проверить явно неправильный почтовый адрес? даже если мне нужно «быть абсолютно уверенным в том, что введенное пользователем на самом деле является электронным письмом», я проверю только те адреса электронной почты, которые соответствуют регулярному выражению
Показать ещё 11 комментариев
185

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

<form><input type="email" placeholder="[email protected]">
    <input type="submit">
</form>

jsFiddle ссылка

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

A действительный адрес электронной почты - это строка, соответствующая типу email следующего ABNF, набор символов которого является Unicode.

email   = 1*( atext / "." ) "@" label *( "." label )
label   = let-dig [ [ ldh-str ] let-dig ]  ; limited to a length of 63 characters by RFC 1034 section 3.5
atext   = < as defined in RFC 5322 section 3.2.3 >
let-dig = < as defined in RFC 1034 section 3.5 >
ldh-str = < as defined in RFC 1034 section 3.5 >

Это требование преднамеренное нарушение RFC 5322, которое определяет синтаксис адресов электронной почты, которые одновременно слишком строги (до символа "@" ), слишком неопределенный (после символа "@" ) и слишком слабый (позволяющий использовать комментарии, пробельные символы и кавычки в манерах, незнакомых большинству пользователей).

Следующее регулярное выражение, совместимое с JavaScript и Perl, является реализацией указанного выше определения.

/^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/
  • 23
    это хорошо, но проблема в том, что он должен быть внутри тега form и отправляться с помощью ввода submit , что не каждый может себе позволить. Кроме того, вы не можете оформить сообщение об ошибке.
  • 3
    Я добавил ответ ниже, который освобождает вас от формы и отправки. Но да, браузеры обычно также применяют только некоторые проверки правдоподобия, а не полную проверку RFC 822.
Показать ещё 7 комментариев
106

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

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

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

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)

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

  • 8
    Это именно то, что я делаю. Все эти «сложные» ответы порождают проблемы: они либо не допускают использование маленького кода IDN, либо используют фиксированный набор TLD, либо излишне ограничивают пользователя, чтобы он не использовал символы, такие как [@ çµ.ö, в своем префиксе электронной почты (до @) или доменное имя. JavaScript во внешнем интерфейсе (не для внутреннего использования причины) недостаточно для проверки по соображениям безопасности. Так почему бы просто не помочь пользователю предотвратить основные опечатки. Основные опечатки: забыть TLD или префикс пользователя (перед @), часть домена или mistype @ as . (или наоборот). Конечно, мы должны быть более строгими на стороне сервера.
  • 0
    По некоторым странным причинам [email protected] не работает с этим шаблоном
Показать ещё 6 комментариев
83

В современных браузерах вы можете использовать ответ @Sushil, используя чистый JavaScript и DOM:

function validateEmail(value) {
  var input = document.createElement('input');

  input.type = 'email';
  input.required = true;
  input.value = value;

  return typeof input.checkValidity === 'function' ? input.checkValidity() : /\S+@\S+\.\S+/.test(value);
}

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

  • 4
    Это умная идея, чтобы решить проблему, но она не работает, потому что браузеры также имеют дрянную проверку. Например, .@a проверяется как true в текущих версиях Chrome, Firefox и Safari.
  • 13
    @HenryJackson К сожалению, в этом случае да. Это потому, что в соответствии с RFC это действительный адрес электронной почты (например, интранет). Браузеры будут получать на гриле, если они проверяют слишком узко и выдают ложные негативы.
Показать ещё 5 комментариев
68

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)>)$
  • 2
    Узел не может скомпилировать это регулярное выражение
  • 1
    @Kato: он использует некоторые несовместимые расширения, в том числе (?> Чтобы прекратить возвращать назад, и (?<angle><)…(?(angle)>) чтобы избежать предоставления длинных | .
61

Это правильная версия 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);
}
  • 0
    Тьфу. Это может сработать, но уродливо, не правда ли?
  • 14
    «Форма» функции - это больше, чтобы показать, что она делает :-)
Показать ещё 5 комментариев
52

Корректная проверка адреса электронной почты в соответствии с RFC не может быть достигнута с помощью регулярного выражения, состоящего из одной строки. Статья с лучшим решением, которое я нашел в PHP: " Что такое действительный адрес электронной почты? , Очевидно, он был портирован на Java. Я думаю, что функция слишком сложна для переноса и использования в JavaScript. Порт JavaScript/node.js: https://www.npmjs.com/package/email-addresses.

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

Вот функция JavaScript, которую я использую, чтобы проверить, похожа ли строка на действительный почтовый адрес:

function looksLikeMail(str) {
    var lastAtPos = str.lastIndexOf('@');
    var lastDotPos = str.lastIndexOf('.');
    return (lastAtPos < lastDotPos && lastAtPos > 0 && str.indexOf('@@') == -1 && lastDotPos > 2 && (str.length - lastDotPos) > 2);
}

Объяснение:

  • lastAtPos < lastDotPos: Last @ должен быть перед последним . поскольку @ не может быть частью имени сервера (насколько я знаю).

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

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

  • lastDotPos > 2: перед последней точкой должно быть не менее трех символов, например [email protected].

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

  • 0
    Этот fn выглядит хорошо, но лучше ли это, чем регулярное выражение, написанное в верхнем ответе?
  • 4
    Я сомневаюсь. Я использую его только для проверки того, выглядит ли строка как электронное письмо, и оставляю детали для кода на стороне сервера.
Показать ещё 5 комментариев
48

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

email.indexOf("@") > 0

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

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

  • 2
    что если будет более одного символа '@'? другие запрещенные символы? Этой проверке нельзя доверять ...
  • 1
    Отлично, этот ответ был простым, только дополнительная проверка уровня. уже есть слой на переднем конце, так что это помогает, спасибо
Показать ещё 1 комментарий
38

Это было украдено из 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;}
  • 7
    Это отфильтровывает когда-либо популярные домены .museum и .travel (из-за ограничения в 4 символа после . )
  • 4
    Изменение {2,4} на {2,6} не будет проблемой
Показать ещё 8 комментариев
36

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

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

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

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

Изображение 2015

  • 0
    Это кажется хорошим решением, оно работает и с новыми TLD, и с 1-м письмом.
  • 1
    для [email protected] не работает ...
Показать ещё 2 комментария
26

Сделай это:

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

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

  • 0
    Это принимает только нижний регистр
  • 0
    @Kondal код JavaScript не чувствителен к регистру из-за флага /i в конце регулярного выражения. Я упоминаю тот факт, что это должно быть сравнение без учета регистра, но я сделаю это более ясным.
20

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

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

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

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

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

  • 13
    Это позволяет вводить столько недействительных адресов электронной почты, что это бесполезный совет.
  • 3
    Это не должно быть невозможно отладить вообще. В этой теме есть много прекрасных примеров, которые проверяют дальше, чем "содержит ли он '@". Ваш пример позволяет считать "u @" действительным адресом электронной почты. По крайней мере, оцените, есть ли домен или что-то, что может быть доменом. Ваш пример того, что я бы назвал «агрессивно-ленивым кодированием». Я не уверен, почему вы защищаете его, так как это, безусловно, самый низкий рейтинг ответа в ветке.
Показать ещё 8 комментариев
18

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

<input type="email"/>

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

  • 4
    IE <10 не поддерживает это, как и собственный браузер Android.
  • 1
    Upvoting. IE <10 мертв.
17

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

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

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

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

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

if (reg.test(/@/))

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

12

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

let val = '[email protected]';
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

  • 0
    Это не удалось для стандартного [email protected]
  • 1
    @RickS это просто не правда. Проверьте еще раз, пожалуйста
12

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

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

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

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

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

12

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

  • 0
    Я не вижу вашего регулярного выражения в RFC5322: tools.ietf.org/html/rfc5322 - есть какая-то ошибка?
12

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

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
}
  • 1
    abc@xyz - это абсолютно корректное письмо, которое не распознается вашим регулярным выражением.
  • 1
    Нет, это не так. Правильный шаблон электронной почты - что-то@something.something, abc @ xyz не соответствует этому шаблону. Так что это не правильный адрес.
Показать ещё 7 комментариев
11

В отличие от 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'); }
  • 10
    Вам не нужно == true на вашем примере.
11

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

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

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

  • 1
    Они забыли сбежать от @ .
  • 2
    Вам не нужно.
10

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

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

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

check_email('check@thiscom'); // Returns false
check_email('[email protected]'); // Returns false
check_email(' [email protected]'); // Returns false
check_email('[email protected]'); // Returns true
10

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

Вот текущее верхнее выражение, совместимое с 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
  • 8
    -1 Белый список оставляет желать лучшего - особенно, вы пропустили .jobs . Кроме того, существуют живые IDN (большинство из которых, я признаю, были официально одобрены только после вашего поста - например, .中國 в июне 2010 года; но большинство работали годами).
  • 2
    -1 не используйте постоянные домены верхнего уровня. Там всегда (и будет, например, 2013) могут быть добавлены новые TLD.
Показать ещё 3 комментария
9
<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>
  • 0
    Может быть, если вы добавили объяснение или описание, чтобы пойти с ним? Я не думаю, что вам действительно нужно показывать какие-либо HTML; все люди обеспокоены, это Javascript и регулярное выражение. Если вы уменьшите свой ответ только до jacascript и добавите небольшую рекламу, я дам вам голос.
8

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

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('[email protected]') // Return true
validMail('[email protected].') // Return true
validMail('[email protected]') // Return true
validMail('user@localserver') // Return true
validMail('[email protected]') // Return true
validMail('user+mailbox/[email protected]') // Return true
validMail('"very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"@strange.example.com') // Return true
validMail('!#$%&\'*+-/=?^_'.{|}[email protected]') // 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@[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

8

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

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

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

  • 1
    Не позволяет + в части имени электронной почты.
6

Как написать частное регулярное выражение в Android или Java.

1) USER_NAME = "^[A-Za-z0-9_-]{min number of character,max number of character}$";

2) TELEPHONE = "(^\\+)?[0-9()-]*";

3) TELEPHONE_OPTIONAL = "^($|(^\\+)?[0-9()-]*)$";

4) EMAIL = "[a-zA-Z0-9_\\.\\+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-\\.]+";

5) EMAIL_OPTIONAL = "^($|[a-zA-Z0-9_\\.\\+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-\\.]+)$";

6) WEB_URL = "^($|(http:\\/\\/|https:\\/\\/)?(www.)?([a-zA-Z0-9]+).[a-zA-Z0-9]*.[az]{3}.?([az]+)?)$";

7) WEB_URL_YOUTUBE_BE = "https?\\:\\/\\/(www\\.)?youtu(\\.)?be(\\.com)?\\/.*(\\?v=|\\/v\\/)?[a-zA-Z0-9_\\-]+";

8) POSTAL_ADDRESS = "[a-zA-Z\\d\\s\\-\\,\\#\\.\\+]+";

9) FIELD_NOT_EMPTY = "[^\\s]*";

10) PINCODE = "^([0-9]{6})?$";

11) IFSC_CODE = "^[^\\s]{4}\\d{7}$";

12) SWIFT_CODE = "^([0-9]{10})?$";

13) PINCODE = "^([0-9]{6})?$";

6

Я смешал @mevius и @Boldewyn Code, чтобы создать этот окончательный код для проверки электронной почты с использованием 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,}))$/;
 
  var input = document.createElement('input');
 
  input.type = 'email';
  input.value = email;
 
  return typeof input.checkValidity == 'function' ? input.checkValidity() : re.test(email);
 
}

Я поделился этим кодом в своем блоге здесь.

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

Решение Sectrean отлично работает, но это не удалось мне linter. Поэтому я добавил несколько побегов:

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); 
}
  • 0
    validateEmail ("[email protected]") и validateEmail ("[email protected]") оба возвращают false значение
  • 0
    Броски false для использования апострофа: jsfiddle.net/sE2U6
5

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

  • [email protected] Действительный адрес электронной почты

  • [email protected] содержит точку в поле адреса

  • [email protected] Электронная почта содержит точку с поддоменом

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

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

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

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

  • [email protected] Цифры в адресе действительны

  • [email protected] Даш в доменном имени действителен

  • [email protected] Подчеркивание в поле адреса действительно

  • [email protected] .name действительное Имя домена верхнего уровня

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

  • [email protected] Тире в поле адреса действительна

Вот так:

http://regexr.com/3f07j

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

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

Лучшей практикой является использование встроенного тега электронной почты HTML5.

<input type="email" name="email">

или общий синтаксис электронной почты, как распознавание @и. из строки приведена ниже.

^[a-zA-Z0-9_\-.]+@[a-zA-Z0-9\-]+\.[a-zA-Z0-9\-.]+$

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

  • 0
    Согласно вашему регулярному выражению "_.............. [email protected]" является действительным, что не должно быть!
  • 0
    Вот что я сказал в записке
5

Вот функция, которую я использую для проверки подлинности на лицевой стороне. (Регулярное выражение получено из parsley.js)

<!DOCTYPE html>
<html>
<head>
    <title>Our Company</title>
    <style>
        .form-style {
            color: #ccc;
        }
    </style>
</head>
<body>
    <h1>Email Validation Form Example</h1>
    <input type="text" name="email" id="emailInput" class="form-style">
    <script>
        function validateEmail(emailAddress) {
            var regularExpression = /^((([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]))){2,6}$/i;
             return regularExpression.test(emailAddress);
        }

        function showEmailValidationState(event) {
            if (validateEmail(event.target.value)) {
                document.getElementById("emailInput").style.color = 'black';
            }
        }
    document.getElementById("emailInput").addEventListener("keyup", showEmailValidationState);
    </script>
</body>
</html>
  • 3
    Я люблю регулярные выражения, но не для проверки электронной почты. Получайте удовольствие отладки, если кто-то обнаружит проблему с этим!
  • 2
    Я использовал 3 этапа проверки для электронной почты. Во-первых, я использую HTML5 с типом = требуется электронная почта. 2-й - это регулярное выражение JS, показанное выше, затем последний - на стороне сервера.
Показать ещё 2 комментария
4

Вы также можете попробовать

var string = "[email protected]"
var exp = /(\w(=?@)\w+\.{1}[a-zA-Z]{2,})/i
alert(exp.test(string))
  • 0
    Загляните на en.wikipedia.org/wiki/Email_address#Examples
  • 0
    Этот ответ далек от правильного: [email protected] уже ломает его
Показать ещё 2 комментария
4

Используйте регулярное выражение:

 /^[a-z][a-zA-Z0-9_.]*(\.[a-zA-Z][a-zA-Z0-9_.]*)?@[a-z][a-zA-Z-0-9]*\.[a-z]+(\.[a-z]+)?$/

Пример:

function validateEmail(email) {
    var re = /^[a-z][a-zA-Z0-9_.]*(\.[a-zA-Z][a-zA-Z0-9_.]*)?@[a-z][a-zA-Z-0-9]*\.[a-z]+(\.[a-z]+)?$/;
    return re.test(email);
}

Он должен допускать только @,., _

4

После проверки Regex:

  • Нет пространственных символов до @
  • (-) и (.) не должны быть вместе после @Нет специальных символов после @2 символов до @ Длина электронной почты должна быть менее 128 символов.
function validateEmail(email) {
var chrbeforAt = email.substr(0, email.indexOf('@'));
if (!($.trim(email).length > 127)) {
    if (chrbeforAt.length >= 2) {
        var re = /^(([^<>()[\]{}'^?\\.,!|//#%*-+=&;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/;
        //var re = /[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/;
        return re.test(email);
    } else {
        return false;
    }
} else {
    return false;
}
}
  • 0
    Я закончил тем, что использовал этот, он работает лучше всего для моих нужд, и в основном я просто угнал пользовательскую часть и использовал что-то другое для совпадения после знака @, потому что мне нужна была моя реализация, чтобы позволить пользователям только определенного домена. Но этот умный!
3

Это перевод на JavaScript валидации, предложенной официальным руководством Rails, используемым тысячами веб-сайтов:

/^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i

Относительно просто, но проверяет на наиболее распространенные ошибки.

Протестировано на наборе данных тысяч электронных писем, и в нем не было ни одного ложного негатива/позитива.

Пример использования:

const emailRegex = /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i;

emailRegex.test('[email protected]');    // true

// Multi-word domains
emailRegex.test('[email protected]');  // true
emailRegex.test('[email protected]'); // true

// Valid special characters
emailRegex.test('unusual+but+valid+email1900=/!#$%&\'*+-/=?^_'.{|}[email protected]') // true

// Trailing dots
emailRegex.test('[email protected].'); // false

// No domain
emailRegex.test('email@example');        // false

// Leading space
emailRegex.test(' [email protected]');   // false

// Trailing space
emailRegex.test('[email protected] ');   // false

// Incorrect domains
emailRegex.test('email@example,com ');   // false

// Other invalid emails
emailRegex.test('invalid.email.com')        // false
emailRegex.test('invalid@[email protected]') // false
emailRegex.test('[email protected]')       // false
  • 0
    Не работает для drikk@øl.com или любого другого персонажа за пределами az
3

Если вы используете ng-шаблон и материал, это делает работу.

vm.validateEmail = '([a-zA-Z0-9_.]{1,})((@[a-zA-Z]{2,})[\\\.]([a-zA-Z]{2}|[a-zA-Z]{3}))';
3

лучший: D (RFC-friendly и без ошибок "слишком сложно" ):

function    isMail(mail)
{
    pattuser = /^([A-Z0-9_%+\-!#$&'*\/=?^`{|}~]+\.?)*[A-Z0-9_%+\-!#$&'*\/=?^`{|}~]+$/i;
    pattdomain = /^([A-Z0-9-]+\.?)*[A-Z0-9-]+(\.[A-Z]{2,9})+$/i;

    tab = mail.split("@");
    if (tab.length != 2)
        return false;
    return (pattuser.test(tab[0]) && pattdomain.test(tab[1]));
}
  • 0
    Пользователь разрешает пробелы, что именно там разрешает пробелы?
  • 0
    ты прав, я забыл, что я не принимаю их в этом
3
<pre>
**The personal_info part contains the following ASCII characters.
1.Uppercase (A-Z) and lowercase (a-z) English letters.
2.Digits (0-9).
3.Characters ! # $ % & ' * + - / = ? ^ _ ` { | } ~
4.Character . ( period, dot or fullstop) provided that it is not the first or last character and it will not come one after the other.**
</pre>
*Example of valid email id*
<pre>
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
</pre>
<pre>
xxxx.ourearth.com [@ is not present] 
[email protected] [ tld (Top Level domain) can not start with dot "." ]
@you.me.net [ No character before @ ]
[email protected] [ ".b" is not a valid tld ]
[email protected] [ tld can not start with dot "." ]
[email protected] [ an email should not be start with "." ]
xxxxx()*@gmail.com [ here the regular expression only allows character, digit, underscore and dash ]
[email protected] [double dots are not allowed
</pre>
**javascript mail code**

    function ValidateEmail(inputText)
    {
    var mailformat = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
    if(inputText.value.match(mailformat))
    {
    document.form1.text1.focus();
    return true;
    }
    else
    {
    alert("You have entered an invalid email address!");
    document.form1.text1.focus();
    return false;
    }
    }
  • 0
    Максимум трехсимвольных TLD? Это уже не 1999 год ...
3

Если вы используете Closure, вы можете использовать встроенный тип goog.format.EmailAddress:

http://docs.closure-library.googlecode.com/git/class_goog_format_EmailAddress.html

Например:

goog.format.EmailAddress.isValidAddrSpec("[email protected]")

Обратите внимание, что, читая исходный код (связанный выше), вы можете видеть, что комментарии указывают, что IDN не поддерживаются и что он предназначен только для большинства адресов:

// This is a fairly naive implementation, but it covers 99% of use cases.
// For more details, see http://en.wikipedia.org/wiki/Email_address#Syntax
// TODO(mariakhomenko): we should also be handling i18n domain names as per
// http://en.wikipedia.org/wiki/Internationalized_domain_name
2

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

Как это работает:

function isEmail(email) {
  const 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);
};
1

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

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

В чем проблема? Ну, "a_z%@gmail.com не может существовать, но может существовать такой же адрес через другого провайдера" [email protected].

Зачем? Согласно RFC: https://en.wikipedia.org/wiki/Email_address#RFC_specification.

Я возьму выдержку для облегчения лекции:

The local-part of the email address may use any of these ASCII characters:

- uppercase and lowercase Latin letters A to Z and a to z;
- digits 0 to 9;
- special characters !#$%&'*+-/=?^_'{|}~;
- dot ., provided that it is not the first or last character unless quoted, and provided also that it does not appear consecutively unless quoted (e.g. [email protected] is not allowed but "John..Doe"@example.com is allowed);[6]
Note that some mail servers wildcard local parts, typically the characters following a plus and less often the characters following a minus, so fred+bah@domain and fred+foo@domain might end up in the same inbox as fred+@domain or even as fred@domain. This can be useful for tagging emails for sorting, see below, and for spam control. Braces { and } are also used in that fashion, although less often.
- space and "(),:;<>@[\] characters are allowed with restrictions (they are only allowed inside a quoted string, as described in the paragraph below, and in addition, a backslash or double-quote must be preceded by a backslash);
- comments are allowed with parentheses at either end of the local-part; e.g. john.smith(comment)@example.com and (comment)[email protected] are both equivalent to [email protected].

Итак, я могу иметь адрес электронной почты, например:

A__z/J0hn.sm{it!}[email protected]

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

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

Единственный, кто действительно может подтвердить адрес электронной почты, является поставщиком адреса электронной почты.

Как бороться, так?

Не имеет значения, добавляет ли пользователь недействительный адрес электронной почты почти во всех случаях. Вы можете положиться на HTML 5 input type = "email", который работает рядом с RFC, мало шансов на провал. HTML5 input type = "email" info: https://www.w3.org/TR/2012/WD-html-markup-20121011/input.email.html

Например, это действительный адрес электронной почты RFC:

"very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"@strange.example.com

Но проверка html5 скажет вам, что текст перед @не должен содержать, например, символы "или", что на самом деле неверно.

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

Хорошей практикой при этом является ввод "введите свой адрес электронной почты снова", чтобы избежать ошибок при вводе пользователем. Если вам этого недостаточно, добавьте модальное окно предварительной отправки с заголовком "Это ваш текущий адрес электронной почты?", А затем сообщение, введенное пользователем внутри тега h2, вы знаете, чтобы четко показать, какой адрес -почта они ввели, затем кнопку "да, отправить".

1

Вот простое регулярное выражение, которое просто проверяет основной формат электронной почты, например, X@YC:

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

1
 <input type="email" class="form-control" required="required" placeholder="Email Address" name="Email" id="Email" autocomplete="Email">
 <button class="btn-1 shadow-0 full-width" type="button" id="register">Register account</button>

 $("#register").click(function(){       
    var rea = /^[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])?)*$/;
    var Email = $("#Email").val();
    var x = rea.test(Email);
    if (!x) {
        alert('Type Your valid Email');
        return false;
    }           
 </script>
1

Now ReactNative Version 0.46 Используйте ниже код для проверки электронной почты.

 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,}))$/;
     if (re.test(email)) {
     } else {
       alert('email: ' + "Please enter valid emailID.")
     }
 }
1

Как насчет создания функции, которая будет тестировать любую строку против шаблона электронной почты с использованием регулярного выражения в JavaScript, поскольку мы знаем, что адреса электронной почты могут быть совершенно разными в разных регионах, например, в Великобритании и Австралии, обычно это заканчивается .co.uk или .com.au, поэтому я попытался их охватить, а также проверить, передана ли строка функции, примерно так:

var isEmail = function(str) {
  return typeof str==='string' && /^[\w+\d+._]+\@[\w+\d+_+]+\.[\w+\d+._]{2,8}$/.test(str);
}

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

isEmail('[email protected]'); //true
isEmail('[email protected]'); //true
isEmail('[email protected]'); //true
isEmail('[email protected]'); //true
isEmail('[email protected]'); //true
isEmail('[email protected]'); //true
isEmail('[email protected]'); //true
isEmail('[email protected]#sswzazaaaa'); //false
isEmail('[email protected]'); //false
1

Здесь написано несколько сложных RegEx, которые также работают.

Я тестировал этот, и он тоже работает:

[a-zA-Z0-9._]+[@]+[a-zA-Z0-9]+[.]+[a-zA-Z]{2,6}

Пожалуйста, проверьте это здесь: http://www.regextester.com/?fam=97334

Надеюсь, что это поможет.

  • 0
    Единственный, который работал для меня в TypeScript
  • 0
    me@localhost не удается.
1

В nodeJS вы также можете использовать модуль валидатора node и просто использовать это

Установите библиотеку с помощью проверки подлинности npm

var validator = require('validator');

validator.isEmail('[email protected]'); //=> true 
1

Тот, кто использует решение @pvl и хочет, чтобы он передал ESLint Prefer-template, затем здесь версия, в которой я использовал шаблонные литералы вместо строки конкатенация.

validateEmail(email) {
    let sQtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]';
    let sDtext = '[^\\x0d\\x5b-\\x5d\\x80-\\xff]';
    let sAtom = '[^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-\\x3c\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+';
    let sQuotedPair = '\\x5c[\\x00-\\x7f]';
    let sDomainLiteral = `\\x5b(${sDtext}|${sQuotedPair})*\\x5d`;
    let sQuotedString = `\\x22(${sQtext}|${sQuotedPair})*\\x22`;
    let sDomainRef = sAtom;
    let sSubDomain = `(${sDomainRef}|${sDomainLiteral})`;
    let sWord = `(${sAtom}|${sQuotedString})`;
    let sDomain = `${sSubDomain}(\\x2e${sSubDomain})*`;
    let sLocalPart = `${sWord}(\\x2e${sWord})*`;
    let sAddrSpec = `${sLocalPart}\\x40${sDomain}`; // complete RFC822 email address spec
    let sValidEmail = `^${sAddrSpec}$`; // as whole string

    let reValidEmail = new RegExp(sValidEmail);

    return reValidEmail.test(email);
}
1

Что вы думаете о моем решении здесь: Как использовать Angular ввод полей проверки подлинности электронной почты внутри контроллера?

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

1

Это регулярное выражение предотвращает дублирование доменных имен, таких как [email protected], это позволит использовать только домен два раза, например [email protected]. Он также не позволяет statring от числа, такого как [email protected]

regexp: /^([a-zA-Z])+([a-zA-Z0-9_.+-])+\@(([a-zA-Z])+\.+?(com|co|in|org|net|edu|info|gov|vekomy))\.?(com|co|in|org|net|edu|info|gov)?$/,  

Все лучшее!!!!!

  • 0
    Почему вы хотите использовать что-то подобное? Спецификация стандартов адресов электронной почты предполагает, что адреса электронной почты могут начинаться с цифр и могут содержать несколько символов точки как в домене, так и в части lcoal. Этот ответ, кажется, является тем, что вы создали для какого-то совершенно нестандартного сценария, когда вы эффективно дискриминируете людей за наличие адресов электронной почты, которые вам не нравятся! Чтобы немного расширить, адреса электронной почты также могут содержать IP-адреса, так что это может быть даже более ограничительным, чем описано.
  • 0
    Правда !!!!!! Но разные люди могут иметь разные требования, и именно поэтому мы пишем проверки .... не так ли ?????????
Показать ещё 1 комментарий
1

Если вы хотите использовать JQuery и хотите иметь современный подход, используйте маска ввода JQuery с проверкой.

http://bseth99.github.io/projects/jquery-ui/5-jquery-masks.html

Демонстрация того, как простая маска ввода jquery находится здесь: http://codepen.io/anon/pen/gpRyBp

Пример простой маски ввода для даты forexample НЕ полная проверка

 <input id="date" type="text" placeholder="YYYY-MM-DD"/>

и script:

 $("#date").mask("9999-99-99",{placeholder:"YYYY-MM-DD"});
1

После проверки Regex:

  • Нет пространственных символов до @
  • (-) и (.) не должны быть вместе после @
  • Никаких специальных символов после @2 символов до @
  • Длина электронной почты должна быть меньше 128 символов

    function validateEmail(email) {
        var chrbeforAt = email.substr(0, email.indexOf('@'));
        if (!($.trim(email).length > 127)) {
            if (chrbeforAt.length >= 2) {
                var re = /^(([^<>()[\]{}'^?\\.,!|//#%*-+=&;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/;
                return re.test(email);
            } else {
                return false;
            }
        } else {
            return false;
        }
    }
    
1

Я знаю его не регулярное выражение, а каким-то образом...

Это пример с node и пакетом npm email-existence, это полная проверка, существует ли электронная почта и если она в правильной форме: )

Это приведет к отправке сообщения электронной почты, если он ответит, если он не получит ответа, он вернет false или true.

function doesEmailExist(email) {
    var emailExistence = require('email-existence');
    return emailExistence.check(email,function (err,status) {
            if (status) {
                return status;
            }
            else {
                throw new Error('Email does not exist');
            }
        });
}
1

Если вы используете AngularJS, просто добавьте type="email" к элементу ввода:

https://docs.angularjs.org/api/ng/input/input%5Bemail%5D

Если нет элемента ввода, его можно создать динамически:

var isEmail = $compile('<input ng-model="m" type="email">')($rootScope.$new()).
    controller('ngModel').$validators["email"];

if (isEmail('[email protected]')) {
  console.log('valid');
} 
  • 0
    Но что это за функция парсера электронной почты? Не могли бы вы опубликовать его, чтобы можно было использовать без углов?
  • 0
    Да, если вы собираетесь опубликовать ответ «черного ящика», пожалуйста, найдите RegEx за функцией парсера электронной почты и покажите нам, что он использует.
0

Вы используете https://github.com/chriso/validator.js и просто делаете:

var validator = require('validator');

validator.isEmail('[email protected]'); //=> true

Обратите внимание, что это может работать на клиенте.

0

Вот рекомендуемый шаблон Regex для HTML5 на MDN:

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

/^[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])?)*$/

https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/email#Validation

  • 0
    Хорошо. Вы когда-нибудь пробовали другие методы проверки, такие как службы PHP или API? Как инструмент проверки электронной почты DeBounce.
0

Вы также можете использовать класс New Regex и сделать так:

const validaEmail = function validateEmail(str) { let regex = new RegExp(/([\w\.\-_]+)?\w+@[\w-_]+(\.\w+){1,}/,'igm') return regex.test(str); }

ссылка: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions

0

Часть personal_info содержит следующие символы ASCII.

  1. Прописные (AZ) и строчные (az) английские буквы. Цифры (0-9).
  2. Персонажи ! # $% & '* + -/=? ^ _ '{| } ~
  3. Символ. (точка, точка или полная остановка) при условии, что это не первый или последний символ, и он не будет приходить один за другим.

Доменное имя [например, com, org, net, in, us, info] содержит буквы, цифры, дефисы и точки.

 function ValidateEmail(mail) 
{
 if (/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(myForm.emailAddr.value))
  {
    return (true)
  }
    alert("You have entered an invalid email address!")
    return (false)
}
0

Это работает для меня:

function Email(mail)
{
 if (/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(myForm.emailAddr.value))
  {
    return (true)
  }
    alert("Invalid email address!")
    return (false)
}
0
function ValidateEmail(mail) 
{
  if (/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(myForm.emailAddr.value))
  {
    return (true)
  }
  alert("You have entered an invalid email address!")
  return (false)
}

Ссылочный URL: https://www.w3resource.com/javascript/form/email-validation.php

0

Я написал валидатор электронной почты JavaScript, который полностью совместим с реализацией PHP filter_var($value, FILTER_VALIDATE_EMAIL).

https://github.com/mpyw/FILTER_VALIDATE_EMAIL.js

import validateEmail from 'filter-validate-email'

const value = '...'
const result = validateEmail(value)

эквивалентно:

<?php

$value = '...';
$result = (bool)filter_var($value, FILTER_VALIDATE_EMAIL, FILTER_FLAG_EMAIL_UNICODE);
0

Вот решение, которое работает и включает функциональность проверки/уведомления в форме:

Вы можете запустить его по этой ссылке

JAVASCRIPT

(function() {
  'use strict';

  window.addEventListener('load', function() {
    var form = document.getElementById('needs-validation');
    form.addEventListener('submit', function(event) {
      if (form.checkValidity() === false) {
        event.preventDefault();
      }
      form.classList.add('was-validated');
      event.preventDefault();              
    }, false);
  }, false);
})();

HTML

<p class='title'>
    <b>Email validation</b>
  <hr size="30px;">
</p>
<br>

<form id="needs-validation" novalidate>
  <p class='form_text'>Try it out!</p>
  <div class="form-row">
    <div class="col-12">
      <input type="email" class="form-control" placeholder="Email Address" required>
        <div class="invalid-feedback">
          Please enter a valid email address.
        </div>
    </div>
  <div class="row">
    <div class="col-12">
      <button type="submit" 
          class="btn btn-default btn-block">Sign up now
      </button>
    </div>
   </div>
</form>
0

Пример ES6

const validateEmail=(email)=> /^(([^<>()\[\]\\.,;:\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,}))$/.test(email);
0

Я хотел бы добавить короткую заметку о символах, отличных от ASCII. Решение Rnevius (и co.) Является блестящим, но оно позволяет добавлять кириллицу, японский, смайликов и другие символы Unicode, которые могут быть ограничены некоторыми серверами.

В приведенном ниже коде будет напечатан true, хотя он содержит символ UTF-8 Ё.

console.log (/^(([^<>()\[\]\\.,;:\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,}))$/.test ('Ё@example.org'))

В моем случае все символы, отличные от ASCII, запрещены, поэтому я изменил исходное выражение, чтобы исключить все символы выше U + 007F:

/^(([^\u0080-\uffff<>()\[\]\\.,;:\s@"]+(\.[^\u0080-\uffff<>()\[\]\\.,;:\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,}))$/

Возможно, это поможет кому-то предотвратить нежелательное поведение.

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

Если вы определяете свое регулярное выражение как строку, все обратные косые черты должны быть экранированы, поэтому вместо '\ w' вы должны иметь "\ w".

В качестве альтернативы, определите его как регулярное выражение:

var pattern = /^\w+@[a-zA-Z_]+?\.[a-zA-Z]{2,3}$/; 
0
\b[a-z][\w\d_\.]+@\w+\.[a-z]{2}[a-z]?\.?[a-z]{,2}\s

Это позволяет:

[email protected]    
[email protected]   
[email protected]   
[email protected]
  • 0
    Хорошая попытка: 2 обновления здесь: для диапазонов соответствия мы предоставляем {min,max} . Пустой min - ошибка, но может иметь пустой max . Я имею в виду [az]{,2} не так, напишите как {0,2} . Более того: ваше регулярное выражение показывает kamal@_gmail.com как действительный, который не является!
0

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

function isValidEmailAddress (email) {
    var validEmail = false;
    if (email) {
        email = email.trim().toLowerCase();
        var pattern = /^[\w-']+(\.[\w-']+)*@([a-zA-Z0-9]+[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*?\.[a-zA-Z]{2,6}|(\d{1,3}\.){3}\d{1,3})(:\d{4})?$/;
        validEmail = pattern.exec(email);
    }

    return validEmail;
}

if (typeof String.prototype.trim !== 'function') {
    String.prototype.trim = function() {
        return this.replace(/^\s+|\s+$/g, '');
    };
}
-2

Простое регулярное выражение для email-Id

 String EMAIL_PATTERN ="^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$";
  • 2
    Согласно вашему регулярному выражению "_.............. [email protected]" является действительным, что не должно быть!
-4
function validatecontactEmail(email) { 

 if (/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(email))  
  {  
    return (true)  
  }  

    return (false)  

}
  • 5
    Как насчет просто return /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(email) ?
  • 0
    @MichaelSchilling, который уменьшает читабельность.
-4

Очень просто в JavaScript. следуйте этому коду.

function validate(){
    var email = document.getElementById('Email');
    var filter = /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/;

    if (!filter.test(email.value))
    {
        alert('Please Enter the valid email address');
        email.focus;
        return false;
    }
    else
{
        return true;
    }

HTML код для этого:

form name="form"
     enctype="multipart/form-data"
     name="form"
     action="register.php"
     method="POST" onsubmit="return validate();" >
    <input type="text" placeholder="Enter ur Email Id" id="Email" name="Email" />
    <input type="submit" id="submit" value="save" name="Like" class="button" />
</form>
-6

Регулярное выражение для электронной почты:

var rex_email = /^(([^<>()[\]\\.,;:\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,}))$/;

if(email=="") {
    window.plugins.toast.showShortBottom( "Please enter the details. ", function(a) {
        console.log('toast success: ' + a);
    }, function(b) { });
} else if(!rex_email.test(email)) {
    window.plugins.toast.showShortBottom( "Please enter the valid email id. ", function(a) {
        console.log('toast success: ' + a);
    }, function(b) { });
}
  • 0
    Это работает нормально для моего кода, и регулярное выражение абсолютно верно ..
  • 2
    Это будет работать для очень распространенных, базовых адресов электронной почты, но есть определенные крайние случаи, когда это будет отклонять действительные адреса электронной почты. Если бы вы прочли остальные 36 (!) Ответов здесь, вы бы знали об этом уже сейчас.
-6

Следующее регулярное выражение:

/^([\w]+)(.[\w]+)*@([\w]+)(.[\w]{2,3}){1,2}$/;
  • 0
    Это не соответствует RFC.
-7
function validateEmail(elementValue){        
    var emailPattern = /^[a-zA-Z0-9._]+[a-zA-Z0-9]+@[a-zA-Z0-9]+\.[a-zA-Z]{2,4}$/;  
    return emailPattern.test(elementValue);   
  }   

Возвращает true, если адрес электронной почты действителен. В противном случае он вернет false.

-8

W3Schools дает хороший простой и эффективный script для проверки электронной почты:

function validateEmail(email) {
    var atpos=email.indexOf("@");
    var dotpos=email.lastIndexOf(".");
    if (atpos < 1 || dotpos < atpos+2 || dotpos+2 >= email.length) {
        alert("Not a valid e-mail address");
        return false;
    }
    return true;
}

Обратите внимание, что вам нужно будет удалить пробелы, если они есть, что-то вроде этого:

.replace(/ /g,'')

Источник: Проверка формы JavaScript

  • 4
    abc@xyz - это абсолютно корректное письмо, которое не распознается вашим регулярным выражением.
  • 0
    Это не мое регулярное выражение, это регулярное выражение w3schools, и для простой проверки электронной почты, если вы предпочитаете быть слишком ограничительным, чем недостаточным, это просто работает. Если вы хотите полный пакет, используйте решение Voyager.
Показать ещё 1 комментарий

Ещё вопросы

Сообщество Overcoder
Наверх
Меню