如何在 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)>)$

使用正则表达式可能是在 JavaScript 中验证电子邮件地址的最佳方式。查看从 Chromium 获取的一堆 JSFiddle 测试。

const validateEmail = (email) => {
  return String(email)
    .toLowerCase()
    .match(
      /^(([^<>()[\]\\.,;:\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,}))$/
    );
};

以下是接受 unicode 的正则表达式的示例。

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

请记住，不应仅依赖 JavaScript 验证，因为客户端可以轻松禁用 JavaScript。此外，在服务器端进行验证也很重要。

以下代码片段是 JavaScript 在客户端验证电子邮件地址的示例。

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

const 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 invalid.');
    $result.css('color', 'red');
  }
  return false;
}

$('#email').on('input', validate);

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

<label for="email">Enter email address</label>
<input id="email" type="email">

<p id="result"></p>

哇，这里有很多复杂性。如果你只想捕捉最明显的语法错误，我会做这样的事情：

^\S+@\S+$

它通常会捕获用户犯的最明显的错误，并确保表单大部分是正确的，这就是 JavaScript 验证的全部内容。

编辑： 我们还可以使用以下命令检查电子邮件中的“.”。

/^\S+@\S+\.\S+$/

当你决定使用正则表达式来验证电子邮件时，你必须明白一些事情：这可能不是一个好主意。一旦你接受了这一点，有许多实现可以让你成功一半，这篇文章很好地总结了它们。

然而，简而言之，要绝对、肯定地确定用户输入的内容实际上是一封电子邮件，唯一的方法是实际发送电子邮件并查看会发生什么。除此之外，这一切都只是猜测。

这是从 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;}

很难让电子邮件验证器100%正确。唯一正确的方法是向该帐户发送测试电子邮件。也就是说，有一些基本的检查可以帮助确保你得到一些合理的东西。

一些需要改进的地方：

而不是 new ，试着这样写出来：RegExpregexp

if (reg.test(/@/))

其次，检查以确保符号后面有一个句点，并确保 s 和句点之间有字符。@@

为了完整起见，这里有另一个符合 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

因此，即使遵循官方标准，仍需要做出权衡。不要盲目地从在线库或论坛中复制正则表达式。始终使用您自己的数据和您自己的应用程序对其进行测试。

_强调我的

这里有一个关于使用正则表达式验证电子邮件地址的非常好的讨论;“比较电子邮件地址验证正则表达式"

以下是当前最热门的表达式，即与 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

取自10年10月1日的 http://fightingforalostcause.net/misc/2006/compare-email-regex.php。

但是，当然，这忽略了国际化。

根据 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 应该在 last 之前，因为不能是服务器名称的一部分（据我所知）。@.@

• lastAtPos > 0：在最后一个之前应该有一些东西（电子邮件用户名）。@

• str.indexOf('@@') == -1：地址中不应有。即使显示为电子邮件用户名中的最后一个字符，它也必须被引用，因此它将位于该字符和地址中的最后一个字符之间。@@@"@@

• lastDotPos > 2：最后一个点之前至少应有三个字符，例如 。[email protected]

• (str.length - lastDotPos) > 2：最后一个点之后应该有足够的字符来形成一个双字符域。我不确定括号是否必要。

HTML5 本身具有电子邮件验证功能。如果您的浏览器支持 HTML5，则可以使用以下代码。

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

jsFiddle 链接

从 HTML5 规范：

有效的电子邮件地址是与以下 ABNF 的生成相匹配的字符串，其字符集为 Unicode。email

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 的，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])?)*$/

不应使用正则表达式来验证输入字符串以检查它是否为电子邮件。它太复杂了，无法涵盖所有情况。

现在，由于您只能涵盖 90% 的情况，因此可以这样写：

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

你可以细化它。例如，“aaa@”是有效的。但总的来说，你明白了要点。不要得意忘形......一个简单的 90% 解决方案比 100% 不起作用的解决方案要好。

世界需要更简单的代码......

我稍微修改了 Jaymon 的答案，供那些想要以以下形式进行真正简单验证的人使用：

[email protected]

正则表达式：

/^\S+@\S+\.\S+$/

要防止匹配多个 @ 符号，请执行以下操作：

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

上面的正则表达式匹配整个字符串，如果要匹配字符串中的任何位置，请删除前导和尾随。下面的示例与字符串中的任意位置匹配。^$

如果你确实想匹配整个吊环，你可能想先匹配字符串。trim()

JavaScript 函数示例：

function validateEmail(email) {
  var re = /\S+@\S+\.\S+/;
  return re.test(email);
}
    
console.log(validateEmail('my email is [email protected]')); // true
    
console.log(validateEmail('my email is anystring@anystring .any')); // false

与 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('yourem[email protected]')){ console.log('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); 
}

这样做：

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

在 https://regex101.com/r/857lzc/1 下进行测试

通常，在数据库中存储电子邮件地址时，我会将它们设置为小写，并且实际上，正则表达式通常可以标记为不区分大小写。在这些情况下，这略短：

[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]') );

注意：
从技术上讲，某些电子邮件可以在符号前的部分中包含引号，并在引号内包含转义字符（因此您的电子邮件用户可能会令人讨厌，并且只要它用引号写成，就包含诸如 和 之类的内容）。从来没有人这样做过！它已经过时了。但是，它包含在真正的 RFC 2822 标准中，此处省略。@@"..."

注2： 电子邮件的开头（在 @ 符号之前）可以区分大小写（通过规范）。但是，任何使用区分大小写的电子邮件的人都可能习惯于遇到问题，并且在实践中，不区分大小写是一个安全的假设。详细信息：电子邮件地址区分大小写吗？

更多的信息： http://www.regular-expressions.info/email.html

在现代浏览器中，您可以使用纯 JavaScript 和 DOM 在 @Sushil 的答案之上进行构建：

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's Answer 的基本验证，它使您摆脱了正则表达式大屠杀，并且不会在旧浏览器上感到厌烦。

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

function checkbae() {
  if (document.layers || document.getElementById || document.all)
    return checkemail()
  else
    return true
}

<form name="validation" onSubmit="return checkbae()">
  Please input a valid email address:<br />

  <input type="text" size=18 name="emailcheck">
  <input type="submit" value="Submit">
</form>

我对正则表达式的了解不是那么好。这就是为什么我首先使用简单的正则表达式检查一般语法，然后使用其他函数检查更具体的选项。这可能不是最好的技术解决方案，但这样我就可以更灵活、更快速。

我遇到的最常见的错误是空格（尤其是在开头和结尾），偶尔还有双点。

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.includes('@')

或者，如果您需要支持 IE/旧版浏览器：

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

node-validator 是这样做的：

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

在验证器函数中使用以下代码：

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 在 MVC 中提供的正 ASP.NET 表达式是

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

我的一位同事与我分享了这个正则表达式。我非常喜欢它。

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

这是我用于前端电子邮件验证的函数。（正则表达式来自 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.log('valid');
} 

我知道它不是正则表达式，但无论如何......

这是 node 和 npm 包 email-existence 的示例，这是最终检查电子邮件是否存在以及其形式是否正确:)

如果电子邮件有响应，这将 ping 电子邮件，如果它没有得到响应，它将返回 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');
            }
        });
}

以下正则表达式验证：

• @ 之前没有空格字符
• （-） 和 （.） 不应在一起 @ 后 @ 后无特殊字符 @ 前必须有 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;
}
}

以下正则表达式验证：

• @ 之前没有空格字符
• （-） 和 （.） 不应在 @ 之后一起
• @ 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]    
abc12[email protected]   
[email protected]   
[email protected]

最好的一个:D（RFC 友好且没有错误“太复杂”）：

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

日期的简单输入掩码示例，例如 NOT 完全验证

 <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\-.]+$

请注意，这仍会生成无效的电子邮件，但仍会匹配 正则表达式，几乎不可能全部捕获它们，但这将 稍微改善一下情况。

我发现这是最好的解决方案：

/^[^\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 在技术上允许的空间，但它们非常罕见，我很乐意这样做。

使用正则表达式：

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

它应该只允许 @ ， ., _

我真的很期待解决这个问题。 所以我修改了上面的电子邮件验证正则表达式

• 源语言
  /^(([^<>()\[\]\\.,;:\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 和 material，则可以完成这项工作。

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

无论谁使用@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);
}

用于验证电子邮件地址的正则表达式

[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 是否存在的解决方案是不完整的。

几乎所有对这个问题的回答都建议使用正则表达式来验证电子邮件地址。我认为正则表达式只适用于基本的验证。似乎电子邮件地址的检查验证实际上是两个独立的问题：

1-电子邮件格式的验证：确保电子邮件是否符合 RFC 5322 中电子邮件的格式和模式，以及 TLD 是否确实存在。可以在此处找到所有有效 TLD 的列表。

例如，尽管该地址将传递正则表达式，但它不是有效的电子邮件，因为它不是 IANA 的顶级域名。[email protected]ccc

2-确保电子邮件确实存在：为此，唯一的选择是向用户发送电子邮件。

我一直在寻找一个通过所有电子邮件地址测试用例的 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 install validator 安装库

var validator = require('validator');

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

如果将正则表达式定义为字符串，则需要对所有反斜杠进行转义，因此应使用“\w”而不是“\w”。

或者，将其定义为正则表达式：

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

这里写了一些复杂的正则表达式，也有效。

我测试了这个，它也可以工作：

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

请在这里测试一下：http://www.regextester.com/?fam=97334

希望这会有所帮助。

我想添加一个关于非 ASCII 字符的简短说明。Rnevius（和公司）的解决方案非常出色，但它允许添加西里尔文、日语、表情符号和其他可能受到某些服务器限制的 unicode 符号。

下面的代码将打印出来，尽管它包含 UTF-8 字符。trueЁ

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,}))$/

也许这将有助于某人防止不良行为。

如何创建一个函数，该函数将使用 JavaScript 中的正则表达式根据电子邮件模式测试任何字符串，因为我们知道电子邮件地址在不同地区可能会有很大不同，例如在英国和澳大利亚，它通常以 or 结尾，所以我也尝试涵盖这些，还要检查传递给函数的字符串， 像这样的东西：.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#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);
}

有效电子邮件 ：

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

无效电子邮件：

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

您也可以尝试

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

正则表达式已更新！试试这个

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

TypScript 版本完成

//
export const emailValid = (val:string):boolean => /^[a-z0-9][a-z0-9-_\.]+@([a-z]|[a-z0-9]?[a-z0-9-]+[a-z0-9])\.[a-z0-9]{2,10}(?:\.[a-z]{2,10})?$/.test(val);

更多信息 https://git.io/vhEfc

 <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)john.s[email protected] are both equivalent to [email protected].

所以，我可以拥有这样的电子邮件地址：

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

如果您尝试此地址，我敢打赌它将在网络上发布的全部或主要正则表达式中失败。但请记住，此地址遵循 RFC 规则，因此它是公平有效的。

想象一下，我无法在使用这些正则表达式检查的任何地方注册而感到沮丧！

唯一真正可以验证电子邮件地址的人是电子邮件地址的提供者。

怎么处理呢？

在几乎所有情况下，用户是否添加无效电子邮件都无关紧要。您可以依靠在 RFC 附近运行的 HTML 5 input type=“email”，失败的可能性很小。 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 标签中输入的邮件，你知道，以清楚地显示他们输入了哪个电子邮件，然后添加一个“是，提交”按钮。

这是数千个网站使用的官方 Rails 指南所建议的验证的 JavaScript 翻译：

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

以下是 MDN 上 HTML5 的推荐正则表达式模式：

支持电子邮件输入类型的浏览器会自动提供验证，以确保只有与 Internet 电子邮件地址的标准格式匹配的文本才会输入到输入框中。实现该规范的浏览器应使用与以下正则表达式等效的算法：

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

这是我是如何做到的。我正在使用 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>

这是我的电子邮件验证器版本。此代码通过面向对象的编程完成，并作为具有静态方法的类实现。你会发现验证器的两个版本：strict（） 和 kind（）。EmailValidator.validateEmailValidator.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('balovbo[email protected]');
} catch (e) {
    console.error(e.message);
}

// Second way.

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

if (isValid)
    console.log(`Email is valid: ${email}.`);
else
    console.log(`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,}))$/

如果你想要一些人类可以阅读和维护的东西，我会推荐 Masala Parser（我是它的创建者之一）。

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.log(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'是正式有效的，但它应该在你的系统中吗？

至少在Masala，你给自己一个理解它的机会。所以明年，同事。

使用浏览器/运行时通过预置协议并将其传递给 API 来处理输入解析，捕获任何错误并检查结果和结果的属性。它基本上可以处理所有转换和可能性（字符集的 punycode 等）。这只能确定输入是可解析的，而不是有效的 - 这只能通过检查目标计算机是否收到该别名的消息来实现。不过，这提供了一个接近（imo 合理）的猜测，如果您愿意维护它并冒着无效拒绝的风险，则可以将其扩展为更具体和现实。（请注意，它不会尝试寻址 IPv4 或 IPv6 地址，而只是使用域处理面向客户的各种方案。URLusernamehostname

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.log(`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.log(validEmail(email), email));

这是我能想到的最简单和最普遍的例子。请在可以使它更准确的情况下对其进行编辑，同时保持其简单性和合理的普遍许可有效性。

另请参阅 MDN URL 文档 URL、窗口。URL 和 Nodejs 用于 URL API。

这些将适用于最常用的电子邮件（它们与每个电子邮件的规则完全匹配）。

Gmail


、雅虎


、Outlook/Hotmail/^[a-z]((?!\.\.)([a-z\.])){4,28}[a-z0-9]@gmail.com$/i/^[a-z]((?!\.\.)([\w\.])){3,30}[\w]@yahoo.com$/i
/[a-z]((?!\.\.)([\w\.])){0,62}[\w]@(outlook.com|hotmail.com)$/i

就我而言，我想避免，这就是为什么我使用了另一种解决方案：~#

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，则可以在后端和前端使用它。

我不懂其他后端语言，所以我无法评估其他用例。

哇，有很多答案包含略有不同的正则表达式。我尝试了很多，我得到了不同的结果和各种不同的问题。

对于 UI 验证，我擅长寻找 @ 符号的最基本检查。需要注意的是，我总是使用标准的“验证电子邮件”进行服务器端验证，其中包含供用户确认其电子邮件地址的唯一链接。

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

即使从零开始，我也特意选择了 0，因为它还可以确保 @ 之前有一个字符。

我更喜欢保持简单，让我的用户满意。我也更喜欢易于理解的代码。正则表达式不是。

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

• 获取最后一个“@”和最后一个“”的位置。
• 确保“@”不是第一个字符（在它之前有一些东西）
• 确保“.”在“@”之后，并且它们之间至少有一个字符
• 确保“”之后至少有一个字符。

这会允许无效的电子邮件地址通过吗？当然，但我认为您不需要更多来获得良好的用户体验，允许您启用/禁用按钮、显示错误消息等。只有当您尝试向该地址发送电子邮件时，您才能确定该地址是否有效。

如果出现此错误：使用正则表达式对安全敏感。

那么这就是你要找的东西。此解决方案没有“正则表达式拒绝服务（ReDoS）”

用于验证电子邮件的正则表达式 （ReDoS）：

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

如果此解决方案适合您，请告诉我。 谢谢。

这里的大多数答案都不是 linter 友好的，一团糟！其中一些也已经过时了！ 在花费大量时间后，我决定使用一个名为 的外部库，例如通过 npm 轻松安装它，并在您自己的项目中导入/需要它：email-validator

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>

电子邮件验证的另一个完美正则表达式

/^([^\s\@])+\@(([^\s\@\.])+\.)+([^\s\.]{2,})+$/

您可以在此处进行测试 https://regex101.com/r/FV3pUI/2

// Try this regular Expression by ES6 function

const emailValidate = (email) => {
  const regexp= /^[\w.%+-]+@[\w.-]+\.[\w]{2,6}$/;
  return regexp.test(email);
}

使用 JavaScript 中的接口以最小的实际预期格式解析地址，然后检查它看起来是否合理。接下来，向它发送一条消息，看看这是否有效（例如，要求收件人通过地址验证一次性令牌）。请注意，这处理的是 punycode、国际化，如以下示例所示。URLuser@host

https://developer.mozilla.org/en-US/docs/Web/API/URL

简单测试示例：

function validEmail(input=''){
    const emailPatternInput = /^[^@]{1,64}@[^@]{4,253}$/, emailPatternUrl = /^[^@]{1,64}@[a-z][a-z0-9\.-]{3,252}$/i;
    let email, url, valid = false, error, same = false;
    try{
        email = input.trim();
        // handles punycode, etc using browser's own maintained implementation
        url = new URL('http://'+email);
        let urlderived = `${url.username}@${url.hostname}`;
        same = urlderived === email;
        valid = emailPatternInput.test( email );
        if(!valid) throw new Error('invalid email pattern on input:' + email);
        valid = emailPatternUrl.test( urlderived );
        if(!valid) throw new Error('invalid email pattern on url:' + urlderived);
    }catch(err){
        error = err;
    };
    return {email, url, same, valid, error};
}

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

这个问题的答案（如果你退后一步认真考虑过）是，你无法真正阻止用户错误地输入他们的电子邮件。每个人都在提供与所有可能的字母相匹配的答案，但没有人真正考虑到可以使用的无数字符。

我向您推荐这篇文章和答案，解释可以接受的字符数量：- 从电子邮件中删除无效字符

你无法预测这些字母是否是用户想要的确切方式 - 这是最常见的错误。缺少一个字母或输入错误的字母。

归根结底，无论你在 Javascript 中做什么，你总是需要你的后端脚本来检查电子邮件是否也成功发送，并且它可能也有一个验证过程。

因此，如果你想确保它是某种电子邮件地址，而不是他们的用户名，你只需要检查那里是否有@符号和至少1个点，其余的都留给你的后端代码。

我提供了一个非常基本的函数，演示了实时输入的延迟检查和即时检查。Javascript 充当第一个检查点来验证基础知识，以节省发布无效内容和惹恼用户。

不过，它总是假设更大的支票在后端。

// Very simple, non-library dependent client-side  e-mail validator
var emailv = {

  // Timeout handler for checkDelay()
  to: null, 
  
  // The core function that takes a string and validates it
  check : function(em){
    
    // Check 1 - The split ensures there's only one @
    var c1 = em.split('@').length == 2;
    
    // Check 2 - Must be at least 1 dot too
    var c2 = em.indexOf('.') > 0;
    
    // Check 3 - ensures there's always something after a @ or dot
    var c3 = !(em.slice(-1)=="@"||em.slice(-1)==".");
    return (c1&&c2&&c3); // If all TRUE, great.
  },
  
  // Shortcut to quickly check any text input by dom id
  checkById : function(inputId){
    d = document.getElementById(inputId);
    return d?emailv.check(d.value):false;
  },
  
  // Check delay for checking on real-time inputs
  checkDelay: function(em){
      clearTimeout(emailv.to);
      emailv.to = setTimeout("emailv.checkDelayP2('"+em+"')",1000);
  },
  
  // Part two  of Check delay
  checkDelayP2: function(em){ 
      if(emailv.check(em)){ // Javascript filter says it seems okay

        // For sakes of this demo, pretend we are now making a background
        // check to see if e-mail is taken. We tell the user to wait..
        emailv.status("Wait..");

        // Pretend the background check took 2 seconds
        // and said e-mail was available
        setTimeout("emailv.status('OK')",2000);
      } else {
        // Javascript say it's bad, mmmkay?
         emailv.status("BAD E-mail");      
      }
  },
  
  status : function(s){
    document.getElementById('emailstatus').innerHTML=s;
  }
}

<h2>1 of 2 - Delayed check</h2>
<ul>
<li><strong>Waits until the user has stopped typing</strong></li>
<li>Useful for when you want to then send e-mail to background database to check if it exists.</li>
<li>Allows them 1 idle second before checking the e-mail address.</li>
</ul>
<input type="text" size="50" id="youremail" name="youremail" onkeyup="emailv.checkDelay(this.value)" onpaste="emailv.checkDelay(this.value)" />
<span id='emailstatus'></span>


<h2>2 of 2 - Instant Check</h2>
<input type="text" size="50" id="youremail2" name="youremail2" />
<a href="Javascript:void(0)" onclick="alert(emailv.checkById('youremail2')?'Seems okay to me':'This e-mail is dodgy')">Check e-mail</a>

最好避免阻止用户输入有效的电子邮件，而不是应用太多限制以使其变得复杂。

这只是我的意见！