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

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

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

function validateEmail(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(String(email).toLowerCase());
}

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

const re = /^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;

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

Вот пример вышеперечисленного в действии:

function validateEmail(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);
}

function validate() {
  const $result = $("#result");
  const 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>

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

^\S+@\S+$

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

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

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

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

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

/^([\w]+)(.[\w]+)*@([\w]+)(.[\w]{2,3}){1,2}$/;

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

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

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

if (reg.test(/@/))

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

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

The official standard is known as RFC 2822. It describes the syntax that valid email addresses must adhere to. You can (but you shouldn't — read on) implement it with this regular expression:

(?:[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])+)\])

(...) We get a more practical implementation of RFC 2822 if we omit the syntax using double quotes and square brackets. It will still match 99.99% of all email addresses in actual use today.

[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?

A further change you could make is to allow any two-letter country code top level domain, and only specific generic top level domains. This regex filters dummy email addresses like [email protected]. You will need to update it as new top-level domains are added.

[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

So even when following official standards, there are still trade-offs to be made. Don't blindly copy regular expressions from online libraries or discussion forums. Always test them on your own data and with your own applications.

_{Emphasis mine}

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

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

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

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

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

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

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

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

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

jsFiddle ссылка

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

A valid e-mail address is a string that matches the email production of the following ABNF, the character set for which is 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 >

This requirement is a willful violation of RFC 5322, which defines a syntax for e-mail addresses that is simultaneously too strict (before the "@" character), too vague (after the "@" character), and too lax (allowing comments, whitespace characters, and quoted strings in manners unfamiliar to most users) to be of practical use here.

The following JavaScript- and Perl-compatible regular expression is an implementation of the above definition.

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

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

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

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

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

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

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

[email protected]

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

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

Чтобы предотвратить совпадение нескольких знаков @:

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

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

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

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

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.info('This is email is valid'); }

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

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

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

Сделай это:

[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.info( emailCheck.test('[email protected]') );

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

Более подробная информация: http://www.regular-expressions.info/email.html

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

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

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

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

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('[email protected]'); // Returns false
check_email(' [email protected]'); // Returns false
check_email('[email protected]'); // Returns true

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

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

<input type = "email"/>

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

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

email.indexOf("@") > 0

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

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

Если вы используете 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

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

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

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

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

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

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
}

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

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

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

Очень просто в 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>

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

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

function validatecontactEmail(email) { 

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

    return (false)  

}

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

Если вы используете 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.info('valid');
} 

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

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.info('toast success: ' + a);
    }, function(b) { });
} else if (!rex_email.test(email)) {
    window.plugins.toast.showShortBottom( "Please enter the valid email id. ", function(a) {
        console.info('toast success: ' + a);
    }, function(b) { });
}

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

Это пример с узлом и пакетом npm адрес электронной почты, это окончательная проверка, существует ли электронная почта и находится ли она в правильной форме :)

Это будет пинговать электронное письмо, если оно отвечает, если оно не получило ответа, оно вернет 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');
            }
        });
}

Следующие проверки 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;
}
}

Следующие проверки 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;
      }
  }
  

\b[a-z][\w\d_\.]+@\w+\.[a-z]{2}[a-z]?\.?[a-z]{,2}\s

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

[email protected]    
[email protected]   
[email protected]   
[email protected]

лучший: 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]));
}

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

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

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

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

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

и сценарий:

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

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

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

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

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

Note that this would still produce invalid email that will still match the regex, its almost impossible to catch them all but this will improve the situation a little.

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

/^[^\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, но они настолько редки, что я счастлив сделать это.

Это регулярное выражение предотвращает дублирование доменных имен, таких как [email protected], оно разрешает только домен два раза, например [email protected]. Он также не позволяет выполнять статистику с таких номеров, как [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)?$/,  

Всего наилучшего !!!!!

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

 String EMAIL_PATTERN  = "^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$";

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

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

Он должен разрешать только @,. , _

Я смешал код @mevius и @Boldewyn, чтобы создать этот окончательный код для проверки электронной почты с помощью 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);
 
}

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

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

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

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

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

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

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

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

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

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

[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 можно найти в здесь.

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

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

Я искал 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-.]+]*/

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

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

var validator = require('validator');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

https://en.wikipedia.org/wiki/Email_address#Exampleshttps://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

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

Теперь ReactNative версии 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.")
     }
 }

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

var string = "[email protected]"
var exp = /(\w(=?@)\w+\.{1}[a-zA-Z]{2,})/i
alert(exp.test(string))

Обновление 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.info('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

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

Вот простое регулярное выражение, которое просто проверяет базовый формат электронного письма, например, [email protected]:

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

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

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

В чем проблема? Ну, «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" информация: https://www.w3.org/TR/2012/WD-html-markup-20121011/input.email.html

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

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

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

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

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

Как написать конкретное регулярное выражение в 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]*.[a-z]{3}.?([a-z]+)?)$";

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})?$";

Это перевод на 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

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

Можно запустить по этой ссылке

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>

Я написал валидатор электронной почты на 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);

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

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

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

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

1. Прописные (A-Z) и строчные (a-z) английские буквы. Цифры (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)
}

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

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

См. Руководство по регулярным выражениям в MDN для получения дополнительной информации.

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

Browsers that support the email input type automatically provide validation to ensure that only text that matches the standard format for Internet e-mail addresses is entered into the input box. Browsers that implement the specification should be using an algorithm equivalent to the following regular expression:

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

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

var validator = require('validator');

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

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

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

$(document).ready(function(){
  $('#submit').on('click', function(){
      var email = $('#email').val();
      var pat = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
      if (email.match(pat)){
        $('#email')
          .addClass('input-valid');
        return false;
      } else {
        $('#email')
        	.addClass('input-error')
          .val('');
        return false;
      }
  });
});

.input-error {
  border: 1px solid red;
  color: red;
}

.input-valid {
  border: 1px solid green;
  color: green;
}

<script src = "https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<form>
    <input type = "text" id = "email" placeholder = "[email protected]" class = "">
    <input type = "submit" id = "submit" value = "Send"/>
</form>

Есть моя версия валидатора электронной почты. Этот код выполнен с помощью объектно-ориентированного программирования и реализован как класс со статическими методами. Вы найдете две версии валидаторов: строгую (EmailValidator.validate) и добрую (EmailValidator.validateKind).

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

export class EmailValidator {
    /**
     * @param {string} email
     * @return {string}
     * @throws {Error}
     */
    static validate(email) {
        email = this.prepareEmail(email);

        const isValid = this.validateKind(email);

        if (isValid)
            return email;

        throw new Error(`Got invalid email: ${email}.`);
    }

    /**
     * @param {string} email
     * @return {boolean}
     */
    static validateKind(email) {
        email = this.prepareEmail(email);

        const regex = this.getRegex();

        return regex.test(email);
    }

    /**
     * @return {RegExp}
     * @private
     */
    static getRegex() {
        return /^(([^<>()\[\]\.,;:\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,}))$/;
    }

    /**
     * @param {string} email
     * @return {string}
     * @private
     */
    static prepareEmail(email) {
        return String(email).toLowerCase();
    }
}

Чтобы подтвердить электронную почту, вы можете использовать следующие способы:

// First way.

try {
    EmailValidator.validate('[email protected]');
} catch (e) {
    console.error(e.message);
}

// Second way.

const email = '[email protected]';
const isValid = EmailValidator.validateKind(email);

if (isValid)
    console.info(`Email is valid: ${email}.`);
else
    console.info(`Email is invalid: ${email}.`);

Я использую эту функцию

/**
 * @param {*} email
 */
export const validateEmail = email => {
    return new RegExp(/[\w-]+@([\w-]+\.)+[\w-]+/gm).test(email);
};

Обычное регулярное выражение электронной почты (официальный стандарт RFC 5322): https://emailregex.com/

JavaScript:

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

Найдите знак @ в поле ввода.

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

import {C,Streams} from '@masala/parser'

const illegalCharset = ' @\u00A0\n\t';
const extendedIllegalCharset = illegalCharset + '.';


// Assume '[email protected]'
export function simpleEmail() {

    return C.charNotIn(illegalCharset).rep() // 'nicolas'
        .then(C.char('@'))
        .then(subDns())  //'internal.masala.co.'
        .then(C.charNotIn(extendedIllegalCharset).rep()) //'uk'
        .eos(); // Must be end of the char stream
}

// [email protected] => extract 'internal.masala.co.'
function  subDns() {
    return C.charNotIn(extendedIllegalCharset).rep().then(C.char('.')).rep()
}

function validateEmail(email:string) {
    console.info(email + ': ' + (simpleEmail().parse(Streams.ofString(email)).isAccepted()));
}


validateEmail('[email protected]'); // True
validateEmail('nz@co.'); // False, trailing "."

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

function inQuote() {
    return C.char('"')
        .then(C.notChar('"').rep())
        .then(C.char('"'))
}

function allEmail() {

    return inQuote().or(C.charNotIn(illegalCharset))
        .rep() // repeat (inQuote or anyCharacter)
        .then(C.char('@'))
        .then(subDns())
        .then(C.charNotIn(extendedIllegalCharset).rep())
        .eos() // Must be end of the character stream
        // Create a structure
        .map(function (characters) { return ({ email: characters.join('') }); });
}

'"nicolas""love-quotes"@masala.co.uk' официально действителен, но должен ли он быть в вашей системе?

По крайней мере, с Масалой вы даете себе шанс понять это. И так на следующий год, коллега.

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

^[a-zA-Z0-9][a-zA-Z0-9-_\.]+@([a-zA-Z]|[a-zA-Z0-9]?[a-zA-Z0-9-]+[a-zA-Z0-9])\.[a-zA-Z0-9]{2,10}(?:\.[a-zA-Z]{2,10})?$

Используйте браузер / среду выполнения для обработки входных данных, добавляя протокол и передавая его в API URL, перехватывая любые ошибки и проверяя свойства результата username и hostname. Он будет обрабатывать в основном все преобразования и возможности (Punycode наборов символов и т. д.). Это только устанавливает, что ввод можно анализировать, но не является действительным - это возможно только путем проверки того, получает ли целевой компьютер сообщения для этого псевдонима. Тем не менее, это дает близкое (imo разумное) предположение и может быть расширено, чтобы быть более конкретным и реалистичным, если вам удобно как поддерживать его, так и рисковать недействительными отказами. (Обратите внимание, что он не пытается адресовать адреса IPv4 или IPv6, а просто широкий спектр сценариев, ориентированных на клиента, с использованием домена.)

function validEmail(email=''){
    var $0, url, isValid = false, emailPatternInput = /^[^@]{1,64}@[^@]{4,253}$/, emailPatternUrl = /^[^@]{1,64}@[a-z][a-z0-9\.-]{3,252}$/i;
    email = email.trim();
    try{
        url = new URL('http://'+email);
        $0 = `${url.username}@${url.hostname}`;
        isValid = emailPatternInput.test( email );
        if (!isValid) throw 'invalid email pattern on input:' + email;
        isValid = emailPatternUrl.test( $0 );
        if (!isValid) throw 'invalid email pattern on url:' + $0;
        console.info(`email looks legit "${email}" checking url-parts: "${$0 === email ? '-SAME-':$0}"`);
    }catch(err){
        console.error(`probably not an email address: "${email}"`, err);
    };
    return isValid;
}

['user+this@はじめよう.みんな', 'stuff@things', '[email protected]', 'Jean+Franç[email protected]','هيا@יאללה', '试@例子.测试.مثال.آزمایشی', 'not@@really', 'no'].forEach(email=>console.info(validEmail(email), email));

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

Также см. Документы URL MDN URL, window.URL и Nodejs для API URL.

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

function validateEmail(email){
        var reg = /^([A-Za-z0-9_\-\.])+\@([A-Za-z0-9_\-\.])+\.([A-Za-z]{2,4})$/;

       //your custom code here to check your email address 

}

Они будут работать с наиболее часто используемыми электронными письмами (они точно соответствуют правилам каждого).

Gmail
/^[a-z]((?!\.\.)([a-z\.])){4,28}[a-z0-9]@gmail.com$/i

Yahoo
/^[a-z]((?!\.\.)([\w\.])){3,30}[\w]@yahoo.com$/i

Перспективы / Hotmail
/[a-z]((?!\.\.)([\w\.])){0,62}[\w]@(outlook.com|hotmail.com)$/i

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

function isValidEmail( value ) {
	return /^[\w\-\.\+]+\@[a-zA-Z0-9\.\-]+\.[a-zA-z0-9]{2,5}$/.test( value );
}

console.info( isValidEmail("[email protected]") )

В моем случае я хотел избежать ~ и #, поэтому я использовал другое решение:

function validEmail(email){
  const regex = /^((?!\.)[\w-_.]*[^.])(@\w+)(\.\w+(\.\w+)?[^.\W])$/;
  return regex.test(email);
}

function validEmail(email){
  const regex = /^((?!\.)[\w-_.]*[^.])(@\w+)(\.\w+(\.\w+)?[^.\W])$/;
  return regex.test(email);
}

const emails = [
'[email protected]',
'[email protected]',
'[email protected]',
'pio_#[email protected]',
'pio_pio@#factory.com',
'[email protected]#om',
'[email protected]*om',
'pio^[email protected]'
]

for(const email of emails){
  document.write(email+' : '+validEmail(email)+'</br>');
}

Вы можете использовать это регулярное выражение (из w3resource (* не относится к W3C)):

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

Если вы используете Node, вы можете использовать его как во внутреннем, так и во внешнем интерфейсе.

Я не знаю других серверных языков, поэтому не могу оценить другие варианты использования.

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

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

if (email.indexOf('@') > 0)

Я намеренно выбрал 0 даже с отсчетом от нуля, так как он также гарантирует, что перед @ будет один символ.

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

function isValidEmail(value) {
    const atLocation = value.lastIndexOf("@");
    const dotLocation = value.lastIndexOf("."); 
    return (
        atLocation > 0 &&
        dotLocation > atLocation + 1 &&
        dotLocation < value.length - 1
    );
};

• Получите расположение последнего символа "@" и последнего символа "."
• Убедитесь, что "@" не является первым символом (перед ним что-то есть)
• Убедитесь, что "." стоит после "@" и между ними есть хотя бы один символ
• Убедитесь, что после "." Есть хотя бы один символ.

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

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

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

Regex для проверки писем без (ReDoS):

/^[a-z0-9](?!.*?[^\na-z0-9]{2})[^\s@]+@[^\s@]+\.[^\s@]+[a-z0-9]$/

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

Большинство ответов здесь не подходят для линтера, это беспорядок! Некоторые из них тоже устарели! Потратив много времени, я решил использовать внешнюю библиотеку с именем email-validator, легко установить ее, например, с помощью npm и импортировать / потребовать ее в своем собственном проекте:

https://www.npmjs.com/package/email-validator

//NodeJs
const validator = require("email-validator");
validator.validate("[email protected]"); // true

//TypeScript/JavaScript
import * as EmailValidator from 'email-validator';
EmailValidator.validate("[email protected]"); // true

     // Html form call function name at submit button

    <form name = "form1" action = "#"> 
    <input type='text' name='text1'/>
    <input type = "submit" name = "submit" value = "Submit" 
    onclick = "ValidateEmail(document.form1.text1)"/>
   </from>

    // Write the function name ValidateEmail below

    <script>
     function ValidateEmail(inputText)
    {
  var mailformat = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/;
    if (inputText.value.match(mailformat))
    {
    alert("Valid email address!");
    document.form1.text1.focus();
    return true;
    }
    else
   {
    alert("You have entered an invalid email address!");
    document.form1.text1.focus();
    return false;
    }
    }
   </script>