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

JavaScript可以匹配正则表达式：

emailAddress.match( / some_regex /);

以下是用于电子邮件的RFC22正则表达式：

^((?>[a-zA-Z\d!#$%&'*+\-/=?^_`{|}~]+\x20*|"((?=[\x01-\x7f])[^"\\]|\\[\x01-\x7f])*"\x20*)*(?<angle><))?((?!\.)(?>\.?[a-zA-Z\d!#$%&'*+\-/=?^_`{|}~]+)+|"((?=[\x01-\x7f])[^"\\]|\\[\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)>)$

使用正则表达式可能是最好的方法。您可以看到一堆测试这里（取自铬）

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

下面是接受Unicode的正则表达式的示例：

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

但请记住，不应仅依赖JavaScript验证。JavaScript很容易被禁用。这也应该在服务器端进行验证。

下面是上面的一个例子：

const validateEmail = (email) => {return email.match(/^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/);};
const validate = () => {const $result = $('#result');const email = $('#email').val();$result.text('');
if (validateEmail(email)) {$result.text(email + ' is valid :)');$result.css('color', 'green');} else {$result.text(email + ' is not valid :(');$result.css('color', 'red');}return false;}
$('#email').on('input', validate);

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<label for="email">Enter an email address: </label><input id="email" /><h2 id="result"></h2>

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

^\S+@\S+$

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

编辑：我们还可以使用

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

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

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

这是从http://codesnippets.joyent.com/posts/show/1917偷来的

email = $('email');filter = /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/;if (filter.test(email.value)) {// Yay! validreturn true;}else{return false;}

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

有些事情需要改进：

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

if (reg.test(/@/))

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

只是为了完整性，这里有另一个符合RFC 2822的正则表达式

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

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

您可以进行的进一步更改是允许任何两个字母的国家/地区代码顶级域，并且仅允许特定的通用顶级域。此正则表达式过滤像#0这样的虚拟电子邮件地址。你将需要更新它作为新的顶级域名被添加。

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

因此，即使遵循官方标准，仍然需要权衡。

_{重点是我的}

这是关于使用正则表达式验证电子邮件地址的非常好的讨论；“比较验证正则表达式的电子邮件地址”

这是当前的顶级表达式，与JavaScript兼容，供参考：

/^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+)*\.(aero|arpa|biz|com|coop|edu|gov|info|int|mil|museum|name|net|org|pro|travel|mobi|[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i

显然，就是这样：

/^([\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+\.)*[\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+@((((([a-z0-9]{1}[a-z0-9\-]{0,62}[a-z0-9]{1})|[a-z])\.)+[a-z]{2,6})|(\d{1,3}\.){3}\d{1,3}(\:\d{1,5})?)$/i

从http://fightingforalostcause.net/misc/2006/compare-email-regex.php在10月1'10。

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

根据RFC正确验证电子邮件地址不是用一行正则表达式可以实现的。我在PHP中找到的最好的解决方案是什么是有效的电子邮件地址？。显然，它已被移植到Java。我认为这个函数太复杂了，无法在JavaScript中移植和使用。 JavaScript/node.js端口：https://www.npmjs.com/package/email-addresses。

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

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

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

说明：

• lastAtPos < lastDotPos：最后一个@应该在最后一个.之前，因为@不能成为服务器名称的一部分（据我所知）。

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

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

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

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

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

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

jsFiddle链接

从HTML5规范：

有效的电子邮件地址是与以下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.5atext   = < 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的故意违反，它为电子邮件地址定义了一个语法，该语法同时过于严格（在“@”字符之前）、过于模糊（在“@”字符之后）和过于松懈（允许注释、空格字符和引用字符串以大多数用户不熟悉的方式出现），在这里没有实际用途。

以下JavaScript和Perl兼容的正则表达式是上述定义的实现。

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

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

现在，因为你只能覆盖90%的情况，写这样的东西：

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

你可以改进它。例如，'aaa@'是有效的。但总的来说，你得到了要点。不要被冲昏了头脑……一个简单的90%的解决方案比100%不起作用的解决方案要好。

世界需要更简单的代码…

对于那些想要真正简单验证的人，我稍微修改了Jaymon的回答：

anystring@anystring.anystring

正则表达式：

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

要防止匹配多个@标志：

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

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

如果你想匹配整个sring，你可能想先trim()字符串。

示例JavaScript函数：

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

与松鼠相比，这里有一个复杂的解决方案，但它在正确验证电子邮件方面做得很好：

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

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

这样做：

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

它基于RFC 2822

测试https://regex101.com/r/857lzc/1

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

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

这是它在JavaScript中使用的示例（末尾是不区分大小写的标志i）。

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

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

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

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

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

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/中整理了一个示例。结合杰尼龟的答案中的特征检测和基本验证，它将您从正则表达式大屠杀中解放出来，并且不会影响旧浏览器。

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

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

function check_email(val){if(!val.match(/\S+@\S+\.\S+/)){ // Jaymon's / Squirtle's solution// Do somethingreturn false;}if( val.indexOf(' ')!=-1 || val.indexOf('..')!=-1){// Do somethingreturn false;}return true;}
check_email('check@thiscom'); // Returns falsecheck_email('check@this..com'); // Returns falsecheck_email(' check@this.com'); // Returns falsecheck_email('check@this.com'); // Returns true

这是正确的RFC822版本。

function checkEmail(emailAddress) {var sQtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]';var sDtext = '[^\\x0d\\x5b-\\x5d\\x80-\\xff]';var sAtom = '[^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-\\x3c\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+';var sQuotedPair = '\\x5c[\\x00-\\x7f]';var sDomainLiteral = '\\x5b(' + sDtext + '|' + sQuotedPair + ')*\\x5d';var sQuotedString = '\\x22(' + sQtext + '|' + sQuotedPair + ')*\\x22';var sDomain_ref = sAtom;var sSubDomain = '(' + sDomain_ref + '|' + sDomainLiteral + ')';var sWord = '(' + sAtom + '|' + sQuotedString + ')';var sDomain = sSubDomain + '(\\x2e' + sSubDomain + ')*';var sLocalPart = sWord + '(\\x2e' + sWord + ')*';var sAddrSpec = sLocalPart + '\\x40' + sDomain; // complete RFC822 email address specvar sValidEmail = '^' + sAddrSpec + '$'; // as whole string
var reValidEmail = new RegExp(sValidEmail);
return reValidEmail.test(emailAddress);}

只需检查输入的电子邮件地址是否有效或未使用超文本标记语言。

<input type="email"/>

不需要编写用于验证的函数。

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

email.includes('@')

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

email.indexOf('@') > 0

不要为任何更复杂的事情而烦恼。即使您可以完美地确定一封电子邮件在RFC语法上是否有效，这也不会告诉您它是否属于提供它的人。这才是真正重要的。

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

如果你使用的是闭包，你可以使用内置的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

节点验证器是这样做的：

/^(?:[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+\.)*[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+@(?:(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9\-](?!\.)){0,61}[a-zA-Z0-9]?\.)+[a-zA-Z0-9](?:[a-zA-Z0-9\-](?!$)){0,61}[a-zA-Z0-9]?)|(?:\[(?:(?:[01]?\d{1,2}|2[0-4]\d|25[0-5])\.){3}(?:[01]?\d{1,2}|2[0-4]\d|25[0-5])\]))$/

在您的验证器函数中使用此代码：

var emailID = document.forms["formName"]["form element id"].value;atpos = emailID.indexOf("@");dotpos = emailID.lastIndexOf(".");if (atpos < 1 || ( dotpos - atpos < 2 )){alert("Please enter correct email ID")return false;}

否则，您可以使用jQuery。内部规则定义：

eMailId: {required: true,email: true}

Microsoft在ASP.NETMVC中提供的正则表达式是

/^[\w-]+(\.[\w-]+)*@([a-z0-9-]+(\.[a-z0-9-]+)*?\.[a-z]{2,6}|(\d{1,3}\.){3}\d{1,3})(:\d{4})?$/

我在这里发布，以防它有缺陷-尽管它一直非常适合我的需求。

<pre>**The personal_info part contains the following ASCII characters.1.Uppercase (A-Z) and lowercase (a-z) English letters.2.Digits (0-9).3.Characters ! # $ % & ' * + - / = ? ^ _ ` { | } ~4.Character . ( period, dot or fullstop) provided that it is not the first or last character and it will not come one after the other.**</pre>*Example of valid email id*<pre>yoursite@ourearth.commy.ownsite@ourearth.orgmysite@you.me.netxxxx@gmail.comxxxxxx@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;}}

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

function isValidEmailAddress (email) {var validEmail = false;if (email) {email = email.trim().toLowerCase();var pattern = /^[\w-']+(\.[\w-']+)*@([a-zA-Z0-9]+[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*?\.[a-zA-Z]{2,6}|(\d{1,3}\.){3}\d{1,3})(:\d{4})?$/;validEmail = pattern.exec(email);}
return validEmail;}
if (typeof String.prototype.trim !== 'function') {String.prototype.trim = function() {return this.replace(/^\s+|\s+$/g, '');};}

这是我用于前端电子邮件验证的函数。（正则表达式来自parsley.js）

<!DOCTYPE html><html><head><title>Our Company</title><style>.form-style {color: #ccc;}</style></head><body><h1>Email Validation Form Example</h1><input type="text" name="email" id="emailInput" class="form-style"><script>function validateEmail(emailAddress) {var regularExpression = /^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))){2,6}$/i;return regularExpression.test(emailAddress);}
function showEmailValidationState(event) {if (validateEmail(event.target.value)) {document.getElementById("emailInput").style.color = 'black';}}document.getElementById("emailInput").addEventListener("keyup", showEmailValidationState);</script></body></html>

如果您使用的是AngularJS，只需将type="email"添加到输入元素：

如果没有输入元素，可以动态创建：

var isEmail = $compile('<input ng-model="m" type="email">')($rootScope.$new()).controller('ngModel').$validators["email"];
if (isEmail('email@gmail.com')) {console.log('valid');}

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

这是节点和npm包邮箱存量的示例，这是最终检查电子邮件是否存在以及它的形式是否正确：）

这将ping电子邮件，如果它的响应，如果它没有得到回应，它将返回false或true。

function doesEmailExist(email) {var emailExistence = require('email-existence');return emailExistence.check(email,function (err,status) {if (status) {return status;}else {throw new Error('Email does not exist');}});}

以下正则表达式验证：

• @之前没有空格字符
• （-）和（.）不应该在一起@之后不能有特殊字符@之前必须有2个字符@电子邮件长度应小于128个字符

function validateEmail(email) {var chrbeforAt = email.substr(0, email.indexOf('@'));if (!($.trim(email).length > 127)) {if (chrbeforAt.length >= 2) {var re = /^(([^<>()[\]{}'^?\\.,!|//#%*-+=&;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/;//var re = /[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/;return re.test(email);} else {return false;}} else {return false;}}

以下正则表达式验证：

• @之前没有空格字符
• @之后（-）和（.）不应在一起
• @之后不能有特殊字符@之前必须有2个字符

• 电子邮件长度应少于128个字符

  function validateEmail(email) {var chrbeforAt = email.substr(0, email.indexOf('@'));if (!($.trim(email).length > 127)) {if (chrbeforAt.length >= 2) {var re = /^(([^<>()[\]{}'^?\\.,!|//#%*-+=&;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/;return re.test(email);} else {return false;}} else {return false;}}

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

它允许：

abcxyz123@qwert.comabc123xyz@asdf.co.inabc1_xyz1@gmail1.comabc.xyz@gmail.com.in

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

function    isMail(mail){pattuser = /^([A-Z0-9_%+\-!#$&'*\/=?^`{|}~]+\.?)*[A-Z0-9_%+\-!#$&'*\/=?^`{|}~]+$/i;pattdomain = /^([A-Z0-9-]+\.?)*[A-Z0-9-]+(\.[A-Z]{2,9})+$/i;
tab = mail.split("@");if (tab.length != 2)return false;return (pattuser.test(tab[0]) && pattdomain.test(tab[1]));}

如果您想使用JQuery并希望采用现代方法，那么请使用带有验证的JQuery输入掩码。

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

演示如何简单的jQuery输入掩码在这里：http://codepen.io/anon/pen/gpRyBp

日期前的简单输入掩码示例非完全验证

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

和脚本：

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

最佳做法是使用HTML5内置的电子邮件标签。

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

或者下面给出了识别@和. from字符串的常见电子邮件语法。

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

请注意，这仍然会产生无效邮件仍然匹配正则表达式，它几乎不可能抓住他们所有，但这将稍微改善一下情况

我认为这是最好的解决方案：

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

它允许以下格式：

1.  prettyandsimple@example.com2.  very.common@example.com3.  disposable.style.email.with+symbol@example.com4.  other.email-with-dash@example.com9.  #!$%&'*+-/=?^_`{}|~@example.org6.  "()[]:,;@\\\"!#$%&'*+-/=?^_`{}| ~.a"@example.org7.  " "@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)

它显然是通用的，允许所有重要的国际字符，同时仍然强制执行基本的anything@anything.anything格式。它将阻止RFC技术上允许的空格，但它们非常罕见，我很乐意这样做。

使用正则表达式：

 /^[a-z][a-zA-Z0-9_.]*(\.[a-zA-Z][a-zA-Z0-9_.]*)?@[a-z][a-zA-Z-0-9]*\.[a-z]+(\.[a-z]+)?$/

示例：

function validateEmail(email) {var re = /^[a-z][a-zA-Z0-9_.]*(\.[a-zA-Z][a-zA-Z0-9_.]*)?@[a-z][a-zA-Z-0-9]*\.[a-z]+(\.[a-z]+)?$/;return re.test(email);}

它应该只允许 @ , . , _

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

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

• 修改
  /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()\.,;\s@\"]+\.{0,1})+[^<>()\.,;:\s@\"]{2,})$/

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

您可以在这里中看到结果。

如果你使用的是ng模式和材料，这就可以了。

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

无论谁使用@pvl解决方案并希望它传递ESLint首选模板，那么这里有一个版本，我使用模板文字而不是字符串连接。

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 speclet sValidEmail = `^${sAddrSpec}$`; // as whole string
let reValidEmail = new RegExp(sValidEmail);
return reValidEmail.test(email);}

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

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

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

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

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

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

2.确保电子邮件确实存在：这样做，唯一的选择是向用户发送电子邮件。

我在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-.]+]*/

在nodeJS中，您还可以使用验证器节点模块并简单地使用

使用npm install validator安装库

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

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

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

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

这里写了一些复杂的RegEx，这也有效。

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

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

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

希望这有帮助。

我想补充一点关于非ASCII字符的简短说明。Rnevius（及其合作伙伴）的解决方案非常出色，但它允许添加西里尔文、日文、表情符号和其他Unicode符号，这些符号可能会受到某些服务器的限制。

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

console.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'))

In my case all non-ASCII symbols are prohibited so I have modified the original expression to exclude all characters above U+007F:

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

也许这会帮助某人防止不良行为。

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

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

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

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

维基百科标准邮件语法：

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

功能：

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

有效电子邮件：

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

无效邮件：

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

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

ES6样本

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

你也可以试试

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

Regex更新了！试试这个

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

打字稿版本完成

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

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

 <input type="email" class="form-control" required="required" placeholder="Email Address" name="Email" id="Email" autocomplete="Email"><button class="btn-1 shadow-0 full-width" type="button" id="register">Register account</button>

 $("#register").click(function(){var rea = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;var Email = $("#Email").val();var x = rea.test(Email);if (!x) {alert('Type Your valid Email');return false;}</script>

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

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

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

世界各地有很多人在寻找“统治他们所有人的正则表达式”，但事实是有很多电子邮件提供商。

问题是什么？好吧，“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规则，因此它是公平有效的。

想象一下我的挫败感，无法在任何地方注册与这些正则表达式检查！

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

怎么处理，所以？

如果用户在几乎所有情况下添加了无效的电子邮件并不重要。您可以依靠超文本标记语言5输入type="email"，它正在运行附近到RFC，失败的可能性很小。HTML5输入类型="email"info：https://www.w3.org/TR/2012/WD-html-markup-20121011/input.email.html

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

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

但是html5验证会告诉您@之前的文本不能包含“或（）字符，例如，这实际上是不正确的。

无论如何，您应该通过接受电子邮件地址并向该电子邮件地址发送电子邮件消息来做到这一点，其中包含用户必须访问以确认有效性的代码/链接。

这样做的一个好做法是输入“再次输入您的电子邮件”以避免用户输入错误。如果这对您来说还不够，请添加一个预提交模式窗口，标题为“这是您当前的电子邮件吗？”，然后用户在h2标签中输入的邮件，您知道，以清楚地显示他们输入的电子邮件，然后是“是，提交”按钮。

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

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

相对简单，但针对最常见的错误进行测试。

在数千封电子邮件的数据集上进行了测试，它没有假阴性/阳性。

示例用法：

const emailRegex = /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i;
emailRegex.test('email@example.com');    // true
// Multi-word domainsemailRegex.test('email@example.co.uk');  // trueemailRegex.test('email@mail.gmail.com'); // true
// Valid special charactersemailRegex.test('unusual+but+valid+email1900=/!#$%&\'*+-/=?^_`.{|}~@example.com') // true
// Trailing dotsemailRegex.test('email@example.co.uk.'); // false
// No domainemailRegex.test('email@example');        // false
// Leading spaceemailRegex.test(' email@example.com');   // false
// Trailing spaceemailRegex.test('email@example.com ');   // false
// Incorrect domainsemailRegex.test('email@example,com ');   // false
// Other invalid emailsemailRegex.test('invalid.email.com')        // falseemailRegex.test('invalid@email@domain.com') // falseemailRegex.test('email@example..com')       // false

这是一个有效的解决方案，并以一种形式包含验证/通知功能：

你可以运行它在这个链接

JAVASCRIPT

(function() {'use strict';
window.addEventListener('load', function() {var form = document.getElementById('needs-validation');form.addEventListener('submit', function(event) {if (form.checkValidity() === false) {event.preventDefault();}form.classList.add('was-validated');event.preventDefault();}, false);}, false);})();

超文本标记语言

<p class='title'><b>Email validation</b><hr size="30px;"></p><br>
<form id="needs-validation" novalidate><p class='form_text'>Try it out!</p><div class="form-row"><div class="col-12"><input type="email" class="form-control" placeholder="Email Address" required><div class="invalid-feedback">Please enter a valid email address.</div></div><div class="row"><div class="col-12"><button type="submit"class="btn btn-default btn-block">Sign up now</button></div></div></form>

我写了一个JavaScript电子邮件验证器，它与PHP的filter_var($value, FILTER_VALIDATE_EMAIL)实现完全兼容。

https://github.com/mpyw/FILTER_VALIDATE_EMAIL.js

import validateEmail from 'filter-validate-email'
const value = '...'const result = validateEmail(value)

相当于：

<?php
$value = '...';$result = (bool)filter_var($value, FILTER_VALIDATE_EMAIL, FILTER_FLAG_EMAIL_UNICODE);

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

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

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

https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/email#Validation

我是这样做的。我使用Match（）来检查标准的电子邮件模式，并在输入文本中添加一个类以相应地通知用户。希望有帮助！

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

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

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

这是我的电子邮件验证器版本。这段代码是用面向对象编程完成的，并用静态方法实现为一个类。您会发现两个版本的验证器：严格（EmailValidator.validate）和类型（EmailValidator.validateKind）。

如果电子邮件无效，第一个会抛出错误并返回电子邮件。第二个返回布尔值，表示电子邮件是否有效。在大多数情况下，我更喜欢严格版本。

export class EmailValidator {/*** @param {string} email* @return {string}* @throws {Error}*/static validate(email) {email = this.prepareEmail(email);
const isValid = this.validateKind(email);
if (isValid)return email;
throw new Error(`Got invalid email: ${email}.`);}
/*** @param {string} email* @return {boolean}*/static validateKind(email) {email = this.prepareEmail(email);
const regex = this.getRegex();
return regex.test(email);}
/*** @return {RegExp}* @private*/static getRegex() {return /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;}
/*** @param {string} email* @return {string}* @private*/static prepareEmail(email) {return String(email).toLowerCase();}}

要验证电子邮件，您可以按照以下方式操作：

// First way.
try {EmailValidator.validate('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}.`);elseconsole.log(`Email is invalid: ${email}.`);

我正在使用此功能

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

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

JavaScript：

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

如果你想要一个人可以阅读和保持的东西，我会推荐马萨拉解析器（我是它的创造者之一）。

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'); // TruevalidateEmail('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'正式有效，但它应该在您的系统中吗？

至少在马萨拉，你给自己一个机会去理解它。所以在接下来的一年里，同事。

使用浏览器/运行时通过预先添加协议来处理解析输入，并将其传递给URL API，捕获任何错误并检查结果的username和hostname属性。它将处理基本上所有的转换和可能性（字符集的惩罚码等）。这只确定输入是可解析的，而不是有效的——这只有通过检查目标机器是否收到该别名的消息才有可能。不过，这提供了一个接近（国际海事组织合理）的猜测，如果你愿意维护它，也愿意冒无效拒绝的风险，可以扩展为更具体和现实。（请注意，它并没有尝试解决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));

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

另请参阅url API的MDN URL docsurl、window.URL和Nodejs。

这些将与最常用的电子邮件一起使用（他们完全符合每个人的规则）。

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

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

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

在我的例子中，我想避免~和#，这就是我使用另一种解决方案的原因：

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

function validEmail(email){const regex = /^((?!\.)[\w\-_.]*[^.])(@\w+)(\.\w+(\.\w+)?[^.\W])$/;return regex.test(email);}
const emails = ['pio_pio@factory.com','~pio_pio@factory.com','pio_~pio@factory.com','pio_#pio@factory.com','pio_pio@#factory.com','pio_pio@factory.c#om','pio_pio@factory.c*om','pio^_pio@factory.com']
for(const email of emails){document.write(email+' : '+validEmail(email)+'</br>');}

您可以使用此正则表达式（来自W3Resources（*与W3C无关））：

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

如果您使用Node，您可以在后端和前端中使用它。

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

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

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

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

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

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

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

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

这会允许无效的电子邮件地址通过吗？当然，但我认为您不需要更多的良好用户体验，允许您启用/禁用按钮，显示错误消息等。

如果您收到此错误：使用正则表达式对安全敏感。

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

Regex验证没有（ReDoS）的电子邮件：

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

请让我知道这个解决方案是否适合你。谢谢！

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

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

//NodeJsconst validator = require("email-validator");validator.validate("test@email.com"); // true
//TypeScript/JavaScriptimport * as EmailValidator from 'email-validator';EmailValidator.validate("test@email.com"); // true

     // Html form call function name at submit button
<form name="form1" action="#"><input type='text' name='text1'/><input type="submit" name="submit" value="Submit"onclick="ValidateEmail(document.form1.text1)"/></from>
// Write the function name ValidateEmail below
<script>function ValidateEmail(inputText){var mailformat = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/;if(inputText.value.match(mailformat)){alert("Valid email address!");document.form1.text1.focus();return true;}else{alert("You have entered an invalid email address!");document.form1.text1.focus();return false;}}</script>

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

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

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

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

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

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

一个简单测试的例子：

function validEmail(input=''){const emailPatternInput = /^[^@]{1,64}@[^@]{4,253}$/, emailPatternUrl = /^[^@]{1,64}@[a-z][a-z0-9\.-]{3,252}$/i;let email, url, valid = false, error, same = false;try{email = input.trim();// handles punycode, etc using browser's own maintained implementationurl = new URL('http://'+email);let urlderived = `${url.username}@${url.hostname}`;same = urlderived === email;valid = emailPatternInput.test( email );if(!valid) throw new Error('invalid email pattern on input:' + email);valid = emailPatternUrl.test( urlderived );if(!valid) throw new Error('invalid email pattern on url:' + urlderived);}catch(err){error = err;};return {email, url, same, valid, error};}
['user+this@はじめよう.みんな', 'stuff@things.eu', 'stuff@things', 'user+that@host.com', 'Jean+François@anydomain.museum','هيا@יאללה', '试@例子.测试.مثال.آزمایشی', 'not@@really', 'no'].forEach(email=>console.log(validEmail(email), email));

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

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

您无法预测字母是否与用户预期的完全一致-这是最常见的错误……遗漏一个字母或输入错误的字母。

我们在这里所做的就是阻止他们键入电子邮件地址不接受的非常奇怪的字符，他们意外插入问号的可能性就像他们意外地得到字母“a”和“s”一样。

最终，无论您在Javascript中做什么，您都将始终需要您的后端脚本来检查电子邮件是否也成功发送，并且它可能也会有一个验证过程。

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

var email = 'hello@example.com'if(email.split('@').length == 2 && email.indexOf('.') > 0){// The split ensures there's only 1 @// The indexOf ensures there's at least 1 dot.}

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

这只是我的看法！