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

Question

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

Answer 1

使用正则表达式可能是最好的方法.你可以在这里看到一堆测试(取自铬)

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

我稍微修改了Jaymon的答案,以便那些希望以下列形式进行真正简单验证的人:

anystring@anystring.anystring

正则表达式:

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

示例JavaScript函数:

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

Answer 3

为了完整起见,这里有另一个符合RFC 2822的正则表达式

官方标准称为RFC 2822.它描述了有效电子邮件地址必须遵守的语法.您可以(但不应该 - 继续阅读)使用此正则表达式实现它:

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

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

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

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

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

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

_强调我的

Answer 4

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

^\S+@\S+$

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

Answer 5

你必须要了解第二个你决定使用正则表达式验证电子邮件的东西:这可能不是一个好主意.一旦你接受了这个,有很多实现可以让你到达那里,本文很好地总结了它们.

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

Answer 6

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

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

jsFiddle链接

来自HTML5规范:

一个有效的电子邮件地址是该相匹配的字符串email生产下列ABNF中,对于该字符集是Unicode.

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

此要求是对RFC 5322 的故意违反,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])?)*$/

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的答案中的特征检测和简单验证,它使您摆脱了正则表达式大屠杀,并且不会在旧浏览器上出现问题.

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

所有电子邮件地址都包含"at"(即@)符号.测试必要条件:

email.indexOf("@") > 0

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

要测试它,请发送验证消息.

Answer 12

使用单行正则表达式无法实现符合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 last之前,.因为@不能成为服务器名称的一部分(据我所知).

• lastAtPos > 0:在最后一个之前应该有一些东西(电子邮件用户名)@.

• str.indexOf('@@') == -1:@@地址中应该没有.即使@出现在电子邮件的用户名的最后一个字符,它必须被引用,以便"将是与@最后@的地址.

• lastDotPos > 2:例如,在最后一个点之前应该至少有三个字符a@b.com.

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

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

做这个:

[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,这是一个必须遵守的标准ALL电子邮件地址.

通常,当在数据库中存储电子邮件地址时,我将它们设为小写,并且在实践中,正则表达式通常可以标记为不区分大小写.在这些情况下,这稍微缩短:

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

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

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

传递维基百科电子邮件地址中的示例.

你可以在这里看到结果.

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(/@/))

其次,检查以确保@标志后面有一个句点,并确保@s和句点之间有字符.

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

正则表达式更新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 22

符合RFC5322的最佳正则表达式

__CODE__

Answer 23

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

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

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

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

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

Answer 24

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

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

显然,就是这样:

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

2010 年10月1日来自http://fightingforalostcause.net/misc/2006/compare-email-regex.php.

但是,当然,这忽视了国际化.

Answer 26

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

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

我遇到的最常见的错误是空格(特别是在开头和结尾),偶尔也会出现双点.

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

就我而言，我想避免~，#这就是我使用另一种解决方案的原因：

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

Answer 30

Microsoft MVC在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 31

维基百科标准邮件语法:

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 32

如何在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 33

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

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

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

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

Answer 34

这里的大多数答案都不是 linter 友好的，这是一团糟！其中一些也已经过时了！花了很多时间之后，我决定使用一个名为 的外部库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 35

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

Answer 36

我已经混合了@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);
 
}

我在这里的博客上分享了这段代码.

Answer 37

我在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 38

这是数千个网站使用的官方 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 39

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

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

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

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

Answer 40

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

最佳做法是使用HTML5内置电子邮件标记.

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

或者通用电子邮件语法识别@和.从字符串中给出如下.

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

请注意,这仍然会产生无效的电子邮件,仍然会匹配正则表达式,它几乎不可能捕获所有,但这将改善一些情况.

Answer 42

您也可以尝试

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

Answer 43

这个问题的答案（如果您认真思考一下）是您无法真正防止用户输错电子邮件。每个人都提供与所有可能的字母匹配的答案，但没有人真正考虑到可以使用的所有字符。

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

您无法预测这些字母是否完全符合用户的预期 - 这是最常见的错误。遗漏字母或输入错误的字母。

最终，无论您在 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>

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

这只是我的看法！