如何在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(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>
<button type='submit'>Validate!</button>
</form>
<h2></h2>

• 此正则表达式消除了有效的使用中的电子邮件.不使用.谷歌为"RFC822"或"RFC2822"获得正确的正则表达式.
• 您无法验证电子邮件地址,期限.唯一可以验证电子邮件地址的人是电子邮件地址的提供者.例如,这个答案说这些电子邮件地址:`%2 @ gmail.com,"%2"@ gmail.com,"a..b"@ gmail.com,"a_b"@ gmail.com,_ @ gmail. com,1 @ gmail.com,1_example @ something.gmail.com`都有效,但Gmail绝不会允许任何这些电子邮件地址.您应该通过接受电子邮件地址并向该电子邮件地址发送电子邮件来执行此操作,并使用用户必须访问的代码/链接以确认其有效性.
• @GoodPerson我刚刚给n @ ai发邮件告诉他/她他们有一个很酷的电子邮件地址.但是,唉,gmail不会让我.我怀疑通过电子邮件与他人沟通的问题比我网站的javascript验证更大!但感谢你们迎接挑战.
• 对于所有人评论这是"足够好":看,你只是在想这个问题是错误的.没关系.这是您可以为用户做出的选择.我并不生气.但是,你知道,从技术上讲,你是示范性的,可证明是错误的.
• @Randall:你能举一个这样的电子邮件地址的例子吗？
• 这甚至不接受RFC 822中的示例.一些简单的情况它与 @ b @ c.com,a(b)@c.com不匹配.有关更多信息,请参阅RFC.这是一个正则表达式,不会拒绝任何有效地址[^ @] + @ [^ @] + .[^ @] +并防止常见错误.
• 对于大多数母语为英语的人来说这是一个很好的解决方案,但它没有通过土耳其测试(见Joel Spolsky).允许使用大多数unicode字母,例如在阿根廷,"ñoñó1234@server.com"等地址完全正常.http://www.joelonsoftware.com/articles/Unicode.html
• 注意,这是无效的:`re.test("username+something@gmail.com")`
• 这些天Javascript可以在服务器上运行,所以对于那些认为这只与客户端验证相关的人来说你错了.对于那些说不可能验证电子邮件的人,我相信你一般都错过了验证点.您永远不会为表单编写验证,以确保一切都100%完美,主要有以下两个原因:1.编写逻辑需要花费更多时间.2.总是存在不良数据的边缘情况可以提交.我们验证的原因是鼓励正确的数据提交并防止错误.
• 任何支持使用正则表达式检查电子邮件我100%反对.我厌倦了被告知我的电子邮件地址"foo+bar@gmail.com"无效.最好的选择是要求用户两次输入他们的电子邮件,如果你必须使用正则表达式检查器,那么告诉用户他们的电子邮件地址似乎没有效果,并询问他们是否确定他们输入了它对.甚至还指出了什么没有在正则表达式检查中检查,但不要阻止他们提交表格.
• @BenRoberts n @ ai - 有效的电子邮件地址,在使用中,它失败了
• 标记为无效的有效电子邮件地址示例包括postbox @ com和user @ [IPv6:2001:db8:1ff :: a0b:dbd0]请参阅https://en.wikipedia.org/wiki/Email_address#Valid_email_addresses
• 有人可以解释一下这会是什么,不会与之匹敌？(给出下面的一些额外答案.)了解更多信息以确定用于项目的"解决方案"将会很好.
• http://isemail.info/_system/is_email/test/?all上有完整的电子邮件地址测试用例...(有关详细信息,请参阅http://isemail.info).
• 也无效:`test @ something.melbourne`和其他新顶级域名.
• @rossipedia示例有效的邮件地址,它不解析？例如:``!#!%&'*+ - /=？^ _` {} |〜@ example.org``,或`postbox @ com`,或`@"@ example.org`取自[维基百科] ](http://en.wikipedia.org/wiki/Email_address#Valid_email_addresses)
• 在确定电子邮件地址可能是什么时,还有RFC822以外的因素 - 例如,"a @ a"是有效的RFC822,但ICANN禁止"无网点"域名,因此应视为无效.
• 该答案不接受像"foo+bar@gmail.com"这样的gmail有效电子邮件
• 请注意,在此正则表达式接受之前,任何IDN都必须进行处理.任何有效的顶级IDN都将以punycode形式被拒绝(因为`xn-`前缀与`[a-zA-Z]`不匹配).
• 为什么在`var re = ...`行JSLint上说:Unescaped']',未转义的'[',空格难以统计,使用{2}？
• 本页底部有一个关于RFC2822验证的部分:http://www.regular-expressions.info/email.html
• @BenRoberts MyFakeEmail@dnedomain.com不存在.然而正则表达式将让它通过.
• 显然,您无法使用JavaScript或RegEx验证电子邮件地址.但我认为答案表明"这是一种有效的方式来判断输入电子邮件文本框中的混乱字符是否很可能是一种电子邮件格式.我认为它会让那些会问这个问题的人有足够的合作.如果他们是实际上验证土耳其电子邮件他们应该理解它的限制.否则,使用它直到你遇到麻烦并迭代,就像其他程序员一样!
• 有关它(正确)匹配的更多信息,请参阅以下列表https://emailtester.pieterhordijk.com/test-pattern/MTA4
• 这对于test + google.com无效应该是:var re =/^(([^ <>()[] \.,;: s @ "] +(.[^​​ <>( )[] \;: S @"] +)*)|(" + "))@(( [[0-9] {1,3}[O-. 9] {1,3}[0-9] {1,3}[0-9] {1,3} ])|..(([A-ZA-Z - 0-9] + )+ [A-ZA-Z] {2,}))$ /.
• 对于gmail别名email ids,此验证失败.例如:firstname.lastname+test@gmail.com

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

anystring@anystring.anystring

正则表达式:

/S+@S+.S+/

示例JavaScript函数:

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

• @ImmortalFirefly,你提供的正则表达式实际上匹配`name @ again @ example.com`.尝试将您的行粘贴到JavaScript控制台中.我相信你的意图是只匹配整个文本,这需要文本'^'的开头和文本'$'运算符的结尾.我正在使用的是`/ ^ [^s @] + @ [^s @] + .[^s @] + $/.test('name @ again @ example.com')`
• 您可以实现20倍的长度,这可能会导致少数用户出现问题,并且可能在将来无效,或者您可以获取ImmortalFirefly的版本以确保他们至少付出努力使其看起来真实.根据您的应用程序,可能更容易遇到某人会生气,因为您不接受他们的非传统电子邮件,而不是通过输入不存在的电子邮件地址导致问题的人(他们无论如何都可以通过输入100%有效的RFC2822电子邮件地址,但使用未注册的用户名或域名).Upvoted!
• 根据此验证,此电子邮件有效:请检查@ this..com
• 嗯.[Wikipedia](https://en.wikipedia.org/wiki/Email_address)表示"非常.不可思议.@ .ordinary.com"@ example.com`是一个有效的电子邮件地址.`/^[^s@]+@[^s@]+.[^s@]+$/.test('"very.unusual.@.unusual.com"@example.com") //假.哎呀.
• 这不也允许使用@@@ .. @吗？：D

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

(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[x01-x08x0bx0cx0e-x1fx21x23-x5bx5d-x7f]|\[x01-x09x0bx0cx0e-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-x08x0bx0cx0e-x1fx21-x5ax53-x7f]|\[x01-x09x0bx0cx0e-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

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

_强调我的

• 注意:"在实际使用中*今天*"可能在编写代码时有效,返回200x.代码****可能会在特定年份之后继续使用.(如果我为每一个"meh都有一分钱,没有人会使用4 +通讯TLD,除了那些特定的那些"我必须解决,我可以在全球的铜和镍市场上占据一席之地;))
• @DonRolling不要这样做.这不仅仅意味着"A到Z,a到z",它还意味着" [\] ^ _ `"因为它们之间[http://www.asciitable.com/]" Z"和"a".使用` w`或更好,只需将电子邮件地址小写,然后再对其进行任何操作,因为这无论如何都是惯例.
• 对于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] /
• 此外,第一部分应该是(？:[Az与资本A,以避免当用户资本化他们的电子邮件地址时的误报).
• 根据规范,`d ._.___ d @ gmail.com`不是有效的电子邮件,但仍然检测到它是正确的
• "随着新的顶级域名的添加,您需要更新它." 好吧,现在这么多 - 有超过1500个公认的顶级域名.
• 第二个正则表达式"匹配99.99%"不会阻止`me @ domain.fr.或`.me @ domain.fr`,这可能是一个简单的输入错误而且无效我想如果点"显示为第一个或最后一个字符"对吗？

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

^S+@S+$

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

• @gtournie没人关心.没有人会意外地将其输入电子邮件字段**,这就是所有前端验证都是为了:防止人们在电子邮件字段中意外输入错误的信息,例如他们的名字.
• +1发送电子邮件并查看发生的情况是验证电子邮件地址的唯一真正可靠的方法,除了简单的正则表达式匹配之外,不需要做更多的事情.
• 你仍然可以保持简单但做多一点以确保它有一个"." 在@之后的某个地方只跟着数字或数字,所以像我这里,我@在这里@和我@ herecom这样的东西无效... ^S + @S + [.] [0-9a-z ] + $
• 我认为电子邮件地址可以包含空格.使用`.+ @.+`可能更好
• `/ S + @ S + /。test（“áéíóúý@ÁÉÍÓÚÝð”）`true`
• @MladenJanjetović是的,答案明确指出这不完整.然而,它是最好的答案.没有人需要在前端进行"完整"的电子邮件验证.您需要捕获明显的拼写错误,然后发送确认电子邮件.
• 令人讨厌的是,无论何时你提出电子邮件验证,你都有99%的人在处理关于如何使用正则表达式等不准确的问题.人们,我们不是要弄清楚这是不是真正的电子邮件地址!我们试图确定语法是否正确!

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

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

• -1为什么我要花时间验证一个甚至没有通过正则表达式控件的电子邮件地址？
• @kommradHomer - "正则表达式无效"地址几乎总是有效的,因为用于验证电子邮件地址的正则表达式几乎肯定是错误的并且将排除有效的电子邮件地址.电子邮件地址是`name_part @ domain_part`,几乎任何东西,**包括**和`@`,在name_part中有效; 地址`foo @bar @ machine.subdomain.example.museum`是合法的,虽然它必须作为`foo@bar @ machine ....`进行转义.一旦电子邮件到达域,例如'example.com',该域可以"本地"路由邮件,因此可以存在"奇怪的"用户名和主机名.
• @kommradHomer"正则表达式无效的地址是%100,无效的地址." 对不起...对不起？你知道有多少次我被告知foo+bar@gmail.com不是有效的电子邮件,实际上它是完全有效的吗？!你的逻辑非常缺陷.我已经通过电子邮件提交了表格:thisisafakeemailbutitwillpassyourstupidregexcheck@regexchecksareretarded.com猜猜怎么着？通过REGEX检查...但它不是一个有效的电子邮件(虽然从技术上来说它是,但我保证你不存在......但*划伤他的下巴*).正如许多人所说,这是一个不好的想法....
• 旅行者在http://stackoverflow.com/a/1373724/69697中回答的第二个正则表达是实用的,应该几乎没有误报.我同意@kommradHomer - 如果你不需要发送电子邮件的原因？我可以理解对不可理解的正则表达式的反思性厌恶以及保持代码简单的愿望,但这是几行代码,可以通过立即清除绝对无效的项目来节省您的服务器很多麻烦.正则表达式本身是无益的,但它是服务器端验证的良好补充.
• @dmur我承认"几乎总是有效的"可能是夸大它,但我的网站经常拒绝我的(完全有效且有效的)电子邮件地址,因为我有一个`.us`域名,或者因为我使用过```左边的`+` - 许多地方修复了这些令人震惊的错误,但是本地部分(@的左边)可以是域名所有者想要的*任何东西. - >"foo@bar.com"@ example.com < - 是有效的电子邮件地址.
• @kommradHomer - "为什么我要花时间来验证......"嗯？花你的时间？当然不是,傻!你会编写代码来为你做这件事.然后你实际上知道你是否有一个有效的地址而没有疏远用户的风险.那太酷了!或者你可以噘嘴并挑衅地使用破碎的解决方案.我并不生气.他们是你的用户.

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

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

jsFiddle链接

来自HTML5规范:

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

• 这很好,但问题在于它必须在`form`标签内并通过`submit`输入提交,这并不是每个人都可以做到的.此外,您无法真正设置错误消息的样式.
• @ br1:它不是因为没有"a"顶级域存在而无效.你的内联网是否有决心使用某些IP？
• Html5电子邮件字段类型接受用户@ email等电子邮件
• 我在下面添加了一个答案,将您从表单中解放出来并提交.但是,浏览器通常也只应用一些合理性检查,而不是完整的RFC 822验证.

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

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

• 这正是我在做的事情.所有这些"复杂"的答案都会产生问题:它们要么不允许使用微弱的代码IDN,要么使用一组固定的TLD,或者不必要地限制用户在他们的电子邮件前缀中使用[@çμ.ö这样的字符(在@之前)或域名.前端中的JavaScript(不用于后端使用原因)不足以验证安全性原因.那么为什么不帮助用户防止基本错别字.基本错别字是:忘记TLD或用户前缀(在@之前)或域部分或错误的`@`为`.`(反之亦然).因为我们必须在服务器端限制更多.
• 这个正则表达式是正确的.如果有人输入他们的电子邮件,如'a @ b @ c @ dxy @ .z`,那么他们是否应该度过一段美好时光？:d
• 这不适用于“” @ example.org
• 根据你的正则表达"_.............. kamal@gmail.com"是有效的,这不应该!

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

• @HenryJackson不幸的是,在这种情况下是的.这是因为RFC是一个有效的电子邮件地址(想想内部网).如果浏览器验证过于狭窄并产生漏报,浏览器就会被烧烤.
• 这是一个聪明的想法来解决问题,但它不起作用,因为浏览器也有糟糕的验证.例如`.@ a`在当前版本的Chrome,Firefox和Safari中验证为"true".
• 更新以包含功能检测和优雅降级,现在它不会在新浏览器中中断但使用您喜欢的任何正则表达式.
• 这是迄今为止最原始问题的最佳解决方案.是的,它使用HTML5,但是大多数需要这种精确度的应用程序肯定已经以其他方式依赖HTML5了,所以没有实际意义.我们不可能确定某人的电子邮件是否有效,而无需让他们验证它,所以我们真的不应该投入这么多时间或精力来验证它.快速检查任何明显的语法或尝试的顽皮是我们应该花费的全部努力.

JavaScript可以匹配正则表达式:

emailAddress.match( / some_regex /);

这是电子邮件的RFC22正则表达式:

^((?>[a-zA-Zd!#$%&'*+-/=?^_`{|}~]+x20*|"((?=[x01-x7f])[^"\]|\[x01-x7f])*
"x20*)*(?<angle><))?((?!.)(?>.?[a-zA-Zd!#$%&'*+-/=?^_`{|}~]+)+|"((?=[x01-x
7f])[^"\]|\[x01-x7f])*")@(((?!-)[a-zA-Zd-]+(?<!-).)+[a-zA-Z]{2,}|[(((?(?<
![).)(25[0-5]|2[0-4]d|[01]?d?d)){4}|[a-zA-Zd-]*[a-zA-Zd]:((?=[x01-x7f])
[^\[]]|\[x01-x7f])+)])(?(angle)>)$

• Node似乎无法编译这个正则表达式

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

• 该功能的"形式"更多地展示它的作用:-)
• @BGM:继续编辑,然后.答案是,毕竟标有"社区维基".

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

email.indexOf("@") > 0

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

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

• 怎么会有多个'@'符号怎么办？其他限制符号？此验证不可信任......

使用单行正则表达式无法实现符合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);
}

说明:

• 我对此表示怀疑.我只用它来检查字符串是否像电子邮件一样,并将详细信息留给服务器端代码.

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

• 为什么你不能只做`return filter.test(email.value);`？
• @Anton N:它还有大量的其他问题; 最后的"{2,4}"只是一个有用的指标(如"当你看到那个错误时,其他人可能就在身边").*最基本的*在本地部分缺少"+"; 此评论框太小,无法指出*上面提交的所有错误*.
• 这过滤掉了流行的`.museum`和`.travel`域(由于`.`之后的4个字符限制)
• 将{2,4}更改为{2,6}不会有问题
• @AntonN:现在我们有10个以上的角色TLD(`xn - clchc0ea0b2g2a9gcd`).还不是问题吗？

做这个:

[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

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

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

你可以在这里看到结果.

您不应该使用正则表达式来验证输入字符串以检查它是否是电子邮件.它太复杂了,不会涵盖所有情况.

既然你只能覆盖90%的案例,那就写下:

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

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

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

• 这允许输入这么多无效的电子邮件地址,这是无用的建议.
• +1 - 如果目标是确保用户至少试图输入电子邮件地址,那么检查是否可以确定电子邮件地址绝对不是电子邮件是好的解决方案 一个很好的例子就是你想要一个人的用户名是一个电子邮件地址.如果用户输入'sexy_chick_23',则可以使用此正则表达式为他们提供预期电子邮件的抬头.如果键入的内容看起来像电子邮件,但不是,则用户将永远不会收到"确认"电子邮件,并且永远不会验证注册过程.
• 根本不可能进行调试.这个帖子中有很多很好的例子比"它有一个'@"更有效.你的例子允许"u @"被认为是一个有效的电子邮件地址.至少评估是否存在域名或者某个域名可能是一个域.你的是我称之为"积极懒惰编码"的一个例子.我不知道你为什么要捍卫它,因为它是迄今为止线程中评价最低的答案.
• @cazlab也许你是对的.毕竟我被投了票.与您不同,我不认为上面的任何代码都显示易于调试的代码片段.如果需要的话,至少可以改进我的"积极懒惰"的方法.
• 这与使用正则表达式有什么不同？`(.+)@(.*)`做同样的事情,做得更短.
• @cazlab - 您知道用户的电子邮件地址是否有效而没有向他们发送电子邮件并查看会发生什么情况的用例是什么？您认为正则表达式可以保护您免受什么影响？

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

<input type="email"/>

没有必要编写用于验证的函数.

• IE <10不支持此功能,Android也不支持此浏览器.
• 正在投票。IE &lt;10已死。

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

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

有些事要改进:

而不是新的RegExp,只需尝试写出regexp这样的:

if (reg.test(/@/))

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

在验证器函数中使用此代码:

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
}

• 你是维基百科页面吗？TLD是有效的主机名.所以`abc @ tld`是一个有效的电子邮件地址.
• 不，这不对。正确的电子邮件模式为something@something.something，abc @ xyz与该模式不匹配。因此，它不是有效地址。
• 验证电子邮件地址的唯一方法是发送电子邮件,然后等待响应.除此之外,这里有一个URL,你可以测试你的地址是否符合RFC822:http://mythic-beasts.com/~pdw/cgi-bin/emailvalidate.您可以看到abc @ xyz是RFC822的有效地址.

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

符合RFC5322的最佳正则表达式

__CODE__

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

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

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

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

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

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

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

• -1白名单有很多不足之处 - 值得注意的是,你错过了`.jobs`.此外,还有现场IDN(我承认,其中大多数只是在您的职位后才得到批准 - 例如2010年6月的`.中国`;但大多数已经在工作多年).
• -1不使用恒定的顶级域。总是（例如会有2013年）可以添加新的tld。

显然,就是这样:

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

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

• 你不需要.

与squirtle相比,这是一个复杂的解决方案,但它在正确验证电子邮件方面做得非常好:

function isEmail(email) {
return /^((([a-z]|d|[!#$%&'*+-/=?^_`{|}~]|[u00A0-uD7FFuF900-uFDCFuFDF0-uFFEF])+(.([a-z]|d|[!#$%&'*+-/=?^_`{|}~]|[u00A0-uD7FFuF900-uFDCFuFDF0-uFFEF])+)*)|((x22)((((x20|x09)*(x0dx0a))?(x20|x09)+)?(([x01-x08x0bx0cx0e-x1fx7f]|x21|[x23-x5b]|[x5d-x7e]|[u00A0-uD7FFuF900-uFDCFuFDF0-uFFEF])|(\([x01-x09x0bx0cx0d-x7f]|[u00A0-uD7FFuF900-uFDCFuFDF0-uFFEF]))))*(((x20|x09)*(x0dx0a))?(x20|x09)+)?(x22)))@((([a-z]|d|[u00A0-uD7FFuF900-uFDCFuFDF0-uFFEF])|(([a-z]|d|[u00A0-uD7FFuF900-uFDCFuFDF0-uFFEF])([a-z]|d|-|.|_|~|[u00A0-uD7FFuF900-uFDCFuFDF0-uFFEF])*([a-z]|d|[u00A0-uD7FFuF900-uFDCFuFDF0-uFFEF]))).)+(([a-z]|[u00A0-uD7FFuF900-uFDCFuFDF0-uFFEF])|(([a-z]|[u00A0-uD7FFuF900-uFDCFuFDF0-uFFEF])([a-z]|d|-|.|_|~|[u00A0-uD7FFuF900-uFDCFuFDF0-uFFEF])*([a-z]|[u00A0-uD7FFuF900-uFDCFuFDF0-uFFEF])))$/i.test(email);
}

使用如下:

if (isEmail('youremail@yourdomain.com')){ console.log('This is email is valid'); }

• 你的例子中不需要`== true`.

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

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

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

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

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

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

维基百科标准邮件语法:

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[jk]l@example.com') // Return false
validMail('just"not"right@example.com') // Return false
validMail('this is"notallowed@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

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

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

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

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

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

这里的大多数答案都不是 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

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

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

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

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

开始了 :

http://regexr.com/3f07j

或正则表达式:

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

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

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

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

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

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

这是我用于前端电子邮件验证的功能.(正则表达式来自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">
<script>
function validateEmail(emailAddress) {
var regularExpression = /^((([a-z]|d|[!#$%&'*+-/=?^_`{|}~]|[u00A0-uD7FFuF900-uFDCFuFDF0-uFFEF])+(.([a-z]|d|[!#$%&'*+-/=?^_`{|}~]|[u00A0-uD7FFuF900-uFDCFuFDF0-uFFEF])+)*)|((x22)((((x20|x09)*(x0dx0a))?(x20|x09)+)?(([x01-x08x0bx0cx0e-x1fx7f]|x21|[x23-x5b]|[x5d-x7e]|[u00A0-uD7FFuF900-uFDCFuFDF0-uFFEF])|(\([x01-x09x0bx0cx0d-x7f]|[u00A0-uD7FFuF900-uFDCFuFDF0-uFFEF]))))*(((x20|x09)*(x0dx0a))?(x20|x09)+)?(x22)))@((([a-z]|d|[u00A0-uD7FFuF900-uFDCFuFDF0-uFFEF])|(([a-z]|d|[u00A0-uD7FFuF900-uFDCFuFDF0-uFFEF])([a-z]|d|-|.|_|~|[u00A0-uD7FFuF900-uFDCFuFDF0-uFFEF])*([a-z]|d|[u00A0-uD7FFuF900-uFDCFuFDF0-uFFEF]))).)+(([a-z]|[u00A0-uD7FFuF900-uFDCFuFDF0-uFFEF])|(([a-z]|[u00A0-uD7FFuF900-uFDCFuFDF0-uFFEF])([a-z]|d|-|.|_|~|[u00A0-uD7FFuF900-uFDCFuFDF0-uFFEF])*([a-z]|[u00A0-uD7FFuF900-uFDCFuFDF0-uFFEF]))){2,6}$/i;
return regularExpression.test(emailAddress);
}
function showEmailValidationState(event) {
if (validateEmail(event.target.value)) {
document.getElementById("emailInput").style.color = 'black';
}
}
document.getElementById("emailInput").addEventListener("keyup", showEmailValidationState);
</script>
</body>
</html>

• 我喜欢正则表达式,但不喜欢电子邮件验证.如果有人发现问题,请尽情调试!
• 我一直在使用3阶段验证电子邮件.1,我使用HTML5,需要type = email.第二个是上面显示的JS正则表达式,然后是服务器端.

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

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

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

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

您也可以尝试

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