Question

如何在JavaScript中验证电子邮件地址？

Answer 1

使用regular expressions可能是最好的方法。您可以看到一系列测试here（取自chromium）

function validateEmail(email) {
    var re = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
    return re.test(String(email).toLowerCase());
}

以下是接受unicode的常规表达式示例：

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

但请记住，不应该只依赖JavaScript验证。可以轻松禁用JavaScript。这也应该在服务器端验证。

以上是上述行动的一个例子：

function validateEmail(email) {
  var re = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
  return re.test(email);
}

function validate() {
  var $result = $("#result");
  var email = $("#email").val();
  $result.text("");

  if (validateEmail(email)) {
    $result.text(email + " is valid :)");
    $result.css("color", "green");
  } else {
    $result.text(email + " is not valid :(");
    $result.css("color", "red");
  }
  return false;
}

$("#validate").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>

Answer 2

为了完整起见，here you have another RFC 2822 compliant regex

官方标准称为RFC 2822。它描述了有效电子邮件地址必须遵守的语法。您可以（但不应该 - read on）使用此正则表达式实现它：

(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])

（...）如果我们使用双引号和方括号省略语法，我们会得到更实际的RFC 2822实现。 它仍将匹配当前实际使用的99.99％的电子邮件地址。

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

您可以进行的进一步更改是允许任何双字母国家/地区代码顶级域名，并且只允许特定的通用顶级域名。 此正则表达式会过滤虚拟电子邮件地址，例如asdf@adsf.adsf 。您需要在添加新的顶级域名时更新。

[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+(?:[A-Z]{2}|com|org|net|gov|mil|biz|info|mobi|name|aero|jobs|museum)\b

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

_强调我的

Answer 3

我稍微修改了Jaymon对那些希望以下列形式进行简单验证的人的答案：

anystring@anystring.anystring

正则表达式：

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

JavaScript函数示例：

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

Answer 4

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

^\S+@\S+$

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

Answer 5

您必须要了解第二个决定使用正则表达式验证电子邮件的内容：It's probably not a good idea。一旦你接受了这个，就会有很多实现可以让你到达那里，this article sums them up nicely.

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

Answer 6

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

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

jsFiddle链接

来自HTML5 spec：

有效电子邮件地址是一个字符串，与以下ABNF的email作品相匹配，后者的字符集为Unicode。
email   = 1*( atext / "." ) "@" label *( "." label )
label   = let-dig [ [ ldh-str ] let-dig ]  ; limited to a length of 63 characters by RFC 1034 section 3.5
atext   = < as defined in RFC 5322 section 3.2.3 >
let-dig = < as defined in RFC 1034 section 3.5 >
ldh-str = < as defined in RFC 1034 section 3.5 >
此要求是RFC 5322的willful violation，它定义了同时过于严格（在“@”字符之前），过于模糊（在“@”字符之后）的电子邮件地址的语法，并且太宽松（允许评论，空白字符和大多数用户不熟悉的方式引用的字符串）在这里实用。

以下与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])?)*$/

Answer 7

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

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

它允许以下格式：

1.  prettyandsimple@example.com
2.  very.common@example.com
3.  disposable.style.email.with+symbol@example.com
4.  other.email-with-dash@example.com
9.  #!$%&'*+-/=?^_`{}|~@example.org
6.  "()[]:,;@\\\"!#$%&'*+-/=?^_`{}| ~.a"@example.org
7.  " "@example.org (space between the quotes)
8.  üñîçøðé@example.com (Unicode characters in local part)
9.  üñîçøðé@üñîçøðé.com (Unicode characters in domain part)
10. Pelé@example.com (Latin)
11. δοκιμή@παράδειγμα.δοκιμή (Greek)
12. 我買@屋企.香港 (Chinese)
13. 甲斐@黒川.日本 (Japanese)
14. чебурашка@ящик-с-апельсинами.рф (Cyrillic)

它显然是多功能的，允许所有重要的国际角色，同时仍然执行基本的any@anything.anything格式。它将阻止RFC在技术上允许的空间，但它们非常罕见，我很乐意这样做。

Answer 8

在现代浏览器中，您可以使用纯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的简单验证，它可以让您摆脱正则表达式大屠杀，并且不会在旧浏览器上出现问题。

Answer 9

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

Answer 10

这是正确的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);
}

Answer 11

使用单行正则表达式无法正确验证符合RFC的电子邮件地址。我在PHP中找到的最佳解决方案的文章是 What is a valid email address? 。显然，它已被移植到Java。 ~~我认为该函数太复杂，无法在JavaScript中移植和使用。~~ JavaScript / node.js port：https://www.npmjs.com/package/email-addresses。

一个好的做法是验证客户端上的数据，但要仔细检查服务器上的验证。考虑到这一点，您只需检查字符串是否在客户端上看起来像一个有效的电子邮件地址，并对服务器执行严格检查。

这是我用来检查字符串是否看起来像有效邮件地址的JavaScript函数：

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

说明：

lastAtPos < lastDotPos：上一个@应该在最后.之前，因为@不能成为服务器名称的一部分（据我所知）。
lastAtPos > 0：在最后@之前应该有一些内容（电子邮件用户名）。
str.indexOf('@@') == -1：地址中不应有@@。即使@显示为电子邮件用户名中的最后一个字符，也必须引用它，以便"位于@和地址中的最后一个@之间。
lastDotPos > 2：最后一个点前应至少有三个字符，例如a@b.com。
(str.length - lastDotPos) > 2：在最后一个点之后应该有足够的字符来形成双字符域。我不确定括号是否必要。

Answer 12

所有电子邮件地址都包含“at”（即@）符号。测试必要条件：

email.indexOf("@") > 0

不要打扰任何更复杂的事情。即使您可以完美地确定电子邮件在RFC语法上是否有效，但这并不能告诉您它是否属于提供它的人。这才是真正重要的。

要测试，请发送验证消息。

Answer 13

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

Answer 14

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

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

传递Wikipedia Email Address中的示例。

您可以在here中看到结果。

Answer 15

这样做：

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

为什么呢？ 它基于RFC 2822 ，这是必须遵守的标准所有电子邮件地址。而且我不确定为什么你会为“更简单”的东西而烦恼...无论如何你都会复制并粘贴它;）

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

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

以下是在JavaScript中使用它的示例（最后使用不区分大小写的标记i）。

var emailCheck=/^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i;
console.log( emailCheck.test('some.body@domain.co.uk') );

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

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

Answer 16

您不应该使用正则表达式来验证输入字符串以检查它是否是电子邮件。它过于复杂，无法涵盖所有案例。

现在，因为你只能覆盖90％的案例，所以请写下：

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

你可以改进它。例如，'aaa @'是有效的。但总的来说，你得到了要点。并且不要忘记......一个简单的90％解决方案比不起作用的100％解决方案更好。

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

Answer 17

只需使用HTML检查输入的电子邮件地址是否有效。

<input type="email"/>

无需编写验证功能。

Answer 18

这就是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])\]))$/

Answer 19

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

有待改进的地方：

而不是新的RegExp，只需尝试像这样编写regexp：

if (reg.test(/@/))

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

Answer 20

在验证程序功能中使用此代码：

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
}

Answer 21

符合RFC5322的最佳正则表达式

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

Answer 22

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

let val = 'email@domain.com';
if(/^[a-z0-9][a-z0-9-_\.]+@([a-z]|[a-z0-9]?[a-z0-9-]+[a-z0-9])\.[a-z0-9]{2,10}(?:\.[a-z]{2,10})?$/.test(val)) {
   console.log('passed');
}

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

Answer 23

不检查TLD是否存在的解决方案不完整。

几乎所有这些问题的答案都建议使用Regex来验证电子邮件地址。我认为Regex只对初步验证有好处。似乎电子邮件地址的检查验证实际上是两个独立的问题：

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

例如，虽然地址example@example.ccc将通过正则表达式，但它不是有效的电子邮件，因为ccc不是IANA的顶级域名。

2-确保电子邮件确实存在：为此，唯一选项为to send the users an email。

Answer 24

显然，就是这样：

/^([\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月1日'http://fightingforalostcause.net/misc/2006/compare-email-regex.php拍摄。

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

Answer 25

与 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('youremail@yourdomain.com')){ console.log('This is email is valid'); }

Answer 26

以下是关于使用正则表达式验证电子邮件地址的非常好的讨论; “Comparing E-mail Address Validating Regular Expressions”

以下是当前的顶级表达式，即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

Answer 27

我对regular expressions的了解并不是那么好。这就是为什么我先用简单的正则表达式检查一般语法，然后用其他函数检查更多特定选项。这可能不是最好的技术解决方案，但这种方式我更灵活，更快。

我遇到的最常见错误是空格（特别是在开头和结尾），偶尔会出现双点。

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

check_email('check@thiscom'); // Returns false
check_email('check@this..com'); // Returns false
check_email(' check@this.com'); // Returns false
check_email('check@this.com'); // Returns true

Answer 28

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

Answer 29

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

我在这里发帖以防它有缺陷 - 尽管它总是满足我的需求。

Answer 30

维基百科标准邮件语法：

https://en.wikipedia.org/wiki/Email_address#Examples https://fr.wikipedia.org/wiki/Adresse_%C3%A9lectronique#Syntaxe_exacte

function validMail(mail)
{
    return /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()\.,;\s@\"]+\.{0,1})+([^<>()\.,;:\s@\"]{2,}|[\d\.]+))$/.test(mail);
}

// VALID MAILS

validMail('Abc@example.com') // Return true
validMail('Abc@example.com.') // Return true
validMail('Abc@10.42.0.1') // Return true
validMail('user@localserver') // Return true
validMail('Abc.123@example.com') // Return true
validMail('user+mailbox/department=shipping@example.com') // Return true
validMail('"very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"@strange.example.com') // Return true
validMail('!#$%&\'*+-/=?^_`.{|}~@example.com') // Return true
validMail('"()<>[]:,;@\\\"!#$%&\'-/=?^_`{}| ~.a"@example.org') // Return true
validMail('"Abc@def"@example.com') // Return true
validMail('"Fred Bloggs"@example.com') // Return true
validMail('"Joe.\\Blow"@example.com') // Return true
validMail('Loïc.Accentué@voilà.fr') // Return true
validMail('" "@example.org') // Return true
validMail('user@[IPv6:2001:DB8::1]') // Return true

// INVALID MAILS

validMail('Abc.example.com') // Return false
validMail('A@b@c@example.com') // Return false
validMail('a"b(c)d,e:f;g<h>i[j\k]l@example.com') // Return false
validMail('just"not"right@example.com') // Return false
validMail('this is"not\allowed@example.com') // Return false
validMail('this\ still\"not\\allowed@example.com') // Return false
validMail('john..doe@example.com') // Return false
validMail('john.doe@example..com') // Return false

显示此测试：https://regex101.com/r/LHJ9gU/1

Answer 31

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

Answer 32

Sectrean的解决方案效果很好，但是linter失败了。所以我添加了一些逃脱：

function validateEmail(email){ 
     var re = /^(([^<>()[]\\.,;:\s@\"]+(\.[^<>()[]\\.,;:\s@\"]+)*)|(\".+\"))@(([[0-9]{1,3}\‌.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/; 
     return re.test(email); 
}

Answer 33

我将@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);
 
}

我已在我的博客here上分享了此代码。

Answer 34

我在JS中寻找一个传递所有电子邮件地址测试用例的正则表达式：

email@example.com有效的电子邮件
firstname.lastname@example.com电子邮件在地址栏中包含点
email@subdomain.example.com电子邮件包含带子域的点
firstname+lastname@example.com加号被视为有效字符
email@192.0.2.123域名是有效的IP地址
email@[192.0.2.123] IP地址周围的方括号被视为有效
“email”@example.com有关电子邮件的报价被视为有效
1234567890@example.com地址中的数字有效
email@domain-one.example域名中的短划线有效
_______@example.com地址字段中的下划线有效
email@example.name .name是有效的顶级域名
email@example.co.jp顶级域名中的点也被视为有效（此处使用co.jp作为示例）
firstname-lastname@example.com地址字段中的短划线有效

我们走了：

http://regexr.com/3f07j

或正则表达式：

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

Answer 35

这是我用于前端电子邮件验证的功能。（正则表达式来自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>

Answer 36

最佳做法是使用HTML5内置电子邮件代码。

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

或识别@和的常见电子邮件语法。从字符串中给出如下。

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

请注意，这仍然会产生仍然匹配的无效电子邮件 正则表达式，几乎不可能抓住它们，但这样做稍微改善一下情况。

Answer 37

我希望保持简单，让用户满意。我也更喜欢易于理解的代码。 RegEx不是。

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

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

这将允许无效的电子邮件地址通过吗？可以，但是我认为您不需要更多的用户体验就可以启用/禁用按钮，显示错误消息等。仅当您尝试发送电子邮件时，您才能确定电子邮件地址是否有效到该地址的电子邮件。

Answer 38

遵循正则表达式验证：

@
（ - ）和（。）不应该在一起在@ @之前必须有@ 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;
}
}

Answer 39

使用正则表达式：

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

它应该只允许@ ,. ，_

Answer 40

您也可以尝试

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

Answer 41

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

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

相对简单，但可以针对大多数常见错误进行测试。

在包含数千封电子邮件的数据集上进行了测试，它的误报率/误报率均为零。

用法示例：

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

emailRegex.test('email@example.com');    // true

// Multi-word domains
emailRegex.test('email@example.co.uk');  // true
emailRegex.test('email@mail.gmail.com'); // true

// Valid special characters
emailRegex.test('unusual+but+valid+email1900=/!#$%&\'*+-/=?^_`.{|}~@example.com') // true

// Trailing dots
emailRegex.test('email@example.co.uk.'); // false

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

// Leading space
emailRegex.test(' email@example.com');   // false

// Trailing space
emailRegex.test('email@example.com ');   // false

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

// Other invalid emails
emailRegex.test('invalid.email.com')        // false
emailRegex.test('invalid@email@domain.com') // false
emailRegex.test('email@example..com')       // false

Answer 42

使用W3C特别创建的正则表达式。

带有RegEx的完整解释的参考：

https://www.w3resource.com/javascript/form/email-validation.php

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

如果使用Node，则既可以在后端也可以在前端使用。

我不了解其他后端语言，因此无法评估其他用例。

Answer 43

哇，很多答案都包含略有不同的正则表达式。我已经尝试了许多方法，但结果却不同，所有这些问题都不同。

对于UI验证，我对looking for an @ sign的最基本检查很满意。重要的是要注意，我总是使用标准的“验证电子邮件”来进行服务器端验证，其中包含一个唯一的链接，供用户确认其电子邮件地址。

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

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

Answer 44

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

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

//NodeJs
const validator = require("email-validator");
validator.validate("test@email.com"); // true

//TypeScript/JavaScript
import * as EmailValidator from 'email-validator';
EmailValidator.validate("test@email.com"); // true

Answer 45

如果你正在使用Closure，你可以使用内置的goog.format.EmailAddress类型：

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

例如：

goog.format.EmailAddress.isValidAddrSpec("blah@blah.com")

请注意，通过阅读源代码（上面链接），您可以看到注释表明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

Answer 46

<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>
yoursite@ourearth.com
my.ownsite@ourearth.org
mysite@you.me.net
xxxx@gmail.com
xxxxxx@yahoo.com
</pre>
<pre>
xxxx.ourearth.com [@ is not present] 
xxxx@.com.my [ tld (Top Level domain) can not start with dot "." ]
@you.me.net [ No character before @ ]
xxxx123@gmail.b [ ".b" is not a valid tld ]
xxxx@.org.org [ tld can not start with dot "." ]
.xxxx@mysite.org [ an email should not be start with "." ]
xxxxx()*@gmail.com [ here the regular expression only allows character, digit, underscore and dash ]
xxxx..1234@yahoo.com [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;
    }
    }

Answer 47

最好的一个：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]));
}

Answer 48

如果您正在使用ng-pattern和material，那么就可以完成这项工作。

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

Answer 49

这个问题比初看起来更难以回答。

全世界有很多人在寻找“正则规则来统治所有人”，但事实是电子邮件提供商的口号很多。

有什么问题？好吧，“a_z%@gmail.com不存在，但它可能存在这样的地址，通过另一个提供商”a__z@provider.com。

为什么呢？根据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. John..Doe@example.com 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.smith@example.com are both equivalent to john.smith@example.com.

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

A__z/J0hn.sm{it!}h_comment@example.com.co

如果你试试这个地址，我敢打赌它会全部失败，或者正则表达式的主要部分都在网上发布。但请记住，此地址遵循RFC规则，因此它是公平有效的。

想象一下，我无法注册那些用正则表达式检查过的任何地方，我感到很沮丧!!

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

如何处理，所以？

如果用户几乎在所有情况下都添加了无效的电子邮件，则无关紧要。您可以依赖运行到RFC的HTML 5输入类型=“电子邮件”，几乎没有失败的机会。 HTML5输入类型=“电子邮件”信息：https://www.w3.org/TR/2012/WD-html-markup-20121011/input.email.html

例如，这是一封RFC有效的电子邮件：

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

但是html5验证会告诉你@之前的文本不能包含“或（）chars”，这实际上是不正确的。

无论如何，您应该接受电子邮件地址并向该电子邮件地址发送电子邮件，并使用用户必须访问的代码/链接以确认其有效性。

执行此操作时的一个好习惯是“再次输入您的电子邮件”输入以避免用户输入错误。如果这还不够，请添加一个标题为“这是您当前的电子邮件吗？”的预提交模式窗口，然后用户在h2标签内输入的邮件，以清楚地显示哪个e他们输入了邮件，然后是“是，提交”按钮。

Answer 50

我添加了正则表达式-我为我解决了其他一些小问题，例如其他语言的字符或大写字母

^[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})?$

Answer 51

如果您使用的是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@gmail.com')) {
  console.log('valid');
}

Answer 52

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

这是节点和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');
            }
        });
}

Answer 53

遵循正则表达式验证：

@
（ - ）和（。）不应该在一起
在@

电子邮件长度应少于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;
    }
}

Answer 54

如果你想使用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"});

Answer 55

此regexp可防止重复的域名，如abc@abc.com.com.com.com，它只允许域名两次，如abc@abc.co.in。它也不允许来自123abc@abc.com等数字的statring

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

所有最好!!!!!

Answer 56

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

Answer 57

在nodeJS中，您还可以使用验证器节点模块，只需使用

使用npm install validator

安装库

var validator = require('validator');

validator.isEmail('foo@bar.com'); //=> true

Answer 58

这里写了一些复杂的RegEx，也可以。

我测试了这个，它也有效：

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

请在此处测试：http://www.regextester.com/?fam=97334

希望这有帮助。

Answer 59

如何使用JavaScript中的正则表达式创建一个能够针对电子邮件模式测试任何字符串的函数，因为我们知道不同地区的电子邮件地址可能会有很大不同，例如在英国和澳大利亚，它通常以{{1}结尾}或.com.au，所以我试图覆盖那些，也检查字符串是否传递给函数，如下所示：

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

并检查它是否是如下所示的电子邮件：

isEmail('alex@example.com'); //true
isEmail('alireza@test.co.uk'); //true
isEmail('peter.example@yahoo.com.au'); //true
isEmail('alex@example.com'); //true
isEmail('peter_123@news.com'); //true
isEmail('hello7___@ca.com.pt'); //true
isEmail('example@example.co'); //true
isEmail('hallo@example.coassjj#sswzazaaaa'); //false
isEmail('hallo2ww22@example....caaaao'); //false

Answer 60

现在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.")
     }
 }

Answer 61

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

Answer 62

这是一个简单的正则表达式，可以检查电子邮件的基本格式，例如X@Y.C：

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

Answer 63

以下是推荐的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

Answer 64

这就是我的方法。我正在使用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="name@service.xx" class="">
    <input type="submit" id="submit" value="Send"/>
</form>

Answer 65

在输入字段中搜索@符号。

Answer 66

使用浏览器/运行时通过在协议前添加解析并将输入传递给URL API，捕获任何错误并检查生成的username和hostname属性来解析输入结果。它将基本上处理所有转换和可能性（字符集的punycode等）。这仅确定输入是可解析的，而不是有效的，这只能通过检查目标计算机是否接收到该别名的消息来实现。但是，这提供了一个接近（合理的）猜测，并且如果您既愿意维护它又冒着无效拒绝的风险，可以将其扩展为更具体和现实。（请注意，它不会尝试寻址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.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', 'user+that@host.com', 'Jean+François@anydomain.museum','هيا@יאללה', '试@例子.测试.مثال.آزمایشی', 'not@@really', 'no'].forEach(email=>console.log(validEmail(email), email));

这是我能想到的最简单和最普遍的示例。如果可以使其更准确，同时保持其简单性和合理的总体允许有效性，请对其进行编辑。

另请参见MDN URL文档URL，window.URL和URL API的Nodejs。

Answer 67

您可以尝试RegExp

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

console.log( isValidEmail("mymail@mydomain.com") )

Answer 68

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

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

你可以在这里测试https://regex101.com/r/FV3pUI/2

Answer 69

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

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

Answer 70

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

它允许：

abcxyz123@qwert.com    
abc123xyz@asdf.co.in   
abc1_xyz1@gmail1.com   
abc.xyz@gmail.com.in

Answer 71

如果将正则表达式定义为字符串，则需要对所有反斜杠进行转义，因此不要使用＆＃39; \ w＆＃39;你应该有＆＃39; \ w＆＃39;。

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

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

Answer 72

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

以下代码将打印Ё，但它包含UTF-8字符console.log (/^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/.test ('Ё@example.org'))。

＆＃13;

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

＆＃13;

在我的情况下，禁止所有非ASCII符号，因此我修改了原始表达式以排除U + 007F以上的所有字符：

＆＃13;

{{1}}

＆＃13;

这可能有助于某人防止意外行为。

Answer 73

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

Answer 74

这是一个可行的解决方案，其中包括以下形式的验证/通知功能：

您可以运行at this link

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>

Answer 75

我写了一个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);

Answer 76

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

Answer 77

这对我有用：

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

Answer 78

personal_info部分包含以下ASCII字符。

大写（A-Z）和小写（a-z）英文字母。数字（0-9）。
字符！＃$ %%＆'* +-/ = ^ _`{| }〜
字符。（句点，点或句号），前提是该点不是第一个或最后一个字符，并且不会一个接一个地出现。

域名[例如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)
}

Answer 79

您还可以使用New Regex类并通过以下方式进行操作：

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

参考： https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions

Answer 80

您冷使用https://github.com/chriso/validator.js并只需执行以下操作：

var validator = require('validator');

validator.isEmail('foo@bar.com'); //=> true

请注意，这可以在客户端上使用。

Answer 81

有我的电子邮件验证程序版本。该代码面向OOP，并通过静态方法实现为类。您将找到两种版本的验证器：strict（{EmailValidator.validate）和kind（EmailValidator.validateKind）。如果电子邮件无效，则首先引发错误，否则返回电子邮件。 Second返回布尔值，该值表明电子邮件是否有效。在大多数情况下，我更喜欢严格的版本。

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('balovbohdan@gmail.com');
} catch (e) {
    console.error(e.message);
}

// Second way.

const email = 'balovbohdan@gmail.com';
const isValid = EmailValidator.validateKind(email);

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

Answer 82

我正在使用此功能

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

Answer 83

常规电子邮件正则表达式（RFC 5322官方标准）：https://emailregex.com/

JS：

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

Answer 84

如果您想让人类阅读并维护，我会推荐Masala Parser（我是其中的创造者之一）。

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

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


// Assume 'nicolas@internal.masala.co.uk'
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
}

// x@internal.masala.co.uk => 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('nicolas@internal.masala.co.uk'); // 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一起，您可以让自己有机会了解它。接下来的一年，同事。

Answer 85

对于电子邮件验证，您可以创建自定义函数并使用正则表达式语法来验证电子邮件：

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 

}

Answer 86

这些将与使用最频繁的电子邮件配合使用（它们与每个电子邮件的规则完全匹配）。

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

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

Outlook / Hotmail
/[a-z]((?!\.\.)([\w\.])){0,62}[\w]@(outlook.com|hotmail.com)$/i

Answer 87

就我而言，我想避免使用〜和＃，这就是为什么我使用其他解决方案Click Here以获得更多信息

selectRowList

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

Answer 88

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

这就是您要寻找的。此解决方案不受“正则表达式拒绝服务（ReDoS）”的约束

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

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

请告诉我该解决方案是否适合您。谢谢。

Answer 89

if (rules.isEmail) {
            const pattern = /[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/;
            isValid = pattern.test(value) && isValid
        }

您可以将其用于电子邮件验证。

Answer 90

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

Answer 91

这适用于简单的电子邮件正则表达式：

anythingExceptAtOrSpace@anythingExceptAtOrSpace.anythingExceptAtOrSpace

// @ts-nocheck
const express = require("express");
const router = express.Router();
const ErrorMiddleware = require("../middleware/error.middleware");
const { isAValidInstance } = require("../utils/schema.validator");
const userSchema = require("../database/schemas/user.schema.json");
const User = require("../database/models/user.model");
const logger = require("../log/winston.logger");
const SHA256 = require("js-sha256");
const logLevels = require("../log/log.levels.json").levels;
const ResponseError = require("../responses/response.error");
const ResponseSuccess = require("../responses/response.success");
const { isConnected } = require("../middleware/is.connected");

module.exports = function(passport) {
  router.get(
    "/logout",
    isConnected,
    ErrorMiddleware(function(req, res, next) {
      req.logout();
      res.clearCookie("connect.sid", {
        path: "/"
      });
      // eslint-disable-next-line node/handle-callback-err
      req.session.destroy(function(err) {
        ResponseSuccess.success(res);
      });
    })
  );

  router.get(
    "/me",
    isConnected,
    ErrorMiddleware(async (req, res, next) => {
      ResponseSuccess.success(res, req.user);
    })
  );

  router.post(
    "/login",
    passport.authenticate("local", {
      successRedirect: "/me",
      failureRedirect: "/login"
    })
  );
  router.post(
    "/signup",
    ErrorMiddleware(async (req, res, next) => {
      if (req.user !== undefined) {
        res.redirect("/api/user/me");
        return;
      }
      const user = req.body;
      if (!isAValidInstance(user, userSchema)) {
        logger("POST /auth/signup", logLevels.warn, "Invalid body");
        ResponseError.badRequest(res);
        return;
      }
      user.password = SHA256(user.password);
      const createdUser = await User.createUser(user);
      if (createdUser !== null) {
        ResponseSuccess.success(res, createdUser);
      } else {
        ResponseError.unauthorized(res);
      }
    })
  );
  return router;
};

测试：

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

Answer 92

// Try this regular Expression by ES6 function

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

Answer 93

完全等同于带有 filter_var() 实现的 PHP 的 FILTER_VALIDATE_EMAIL：

mpyw/FILTER_VALIDATE_EMAIL.js: JavaScript Email validation compatible with PHP's filter_var($value, FILTER_VALIDATE_EMAIL)

Answer 94

简单的建议，因为我在答案中看到了混乱。

function validaEmail(email){

  if(email.includes("@")){

    if(email.split("@")[1].includes(".")){
      return true;
    }

  }

  return false;
  
}

Answer 95

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>

Answer 96

电子邮件ID的简单正则表达式

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

Answer 97

function validatecontactEmail(email) { 

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

    return (false)  

}

Answer 98

遵循正则表达式：

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

Answer 99

电子邮件的验证正则表达式：

var rex_email = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;

if(email=="") {
    window.plugins.toast.showShortBottom( "Please enter the details. ", function(a) {
        console.log('toast success: ' + a);
    }, function(b) { });
} else if(!rex_email.test(email)) {
    window.plugins.toast.showShortBottom( "Please enter the valid email id. ", function(a) {
        console.log('toast success: ' + a);
    }, function(b) { });
}

Answer 100

function validateEmail(elementValue){        
    var emailPattern = /^[a-zA-Z0-9._]+[a-zA-Z0-9]+@[a-zA-Z0-9]+\.[a-zA-Z]{2,4}$/;  
    return emailPattern.test(elementValue);   
  }

如果电子邮件地址有效，则返回true。否则，它将返回false。

Answer 101

W3Schools提供了一个简单有效的简单脚本来验证电子邮件：

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

如何在JavaScript中验证电子邮件地址？

101 个答案:

不检查TLD是否存在的解决方案不完整。