5217

使用正则表达式在 JavaScript 中验证电子邮件地址的最佳方法是什么？

4

101 回答 101

6086

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

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

这是html：

<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>
于 2008-09-05T16:15:34.747 回答
1138

对于想要以以下形式进行非常简单验证的人，我稍微修改了 Jaymon 的答案：

anystring@anystring.anystring

正则表达式：

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

为防止匹配多个 @ 符号：

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

示例 JavaScript 函数：

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

于 2012-02-09T02:22:32.837 回答
862

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

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

强调我的

于 2009-09-03T14:26:09.383 回答
465

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

^\S+@\S+$

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

编辑：我们也可以检查“。” 在电子邮件中使用

/^\S+@\S+\.\S+$/
于 2008-09-07T21:21:46.567 回答
356

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

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

于 2009-05-02T17:18:29.030 回答
268

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])?)*$/
于 2011-10-17T08:23:34.947 回答
179

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

/^[^\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（引号之间的空格）
8. üñîçøðé​​@example.com（本地部分的Unicode字符）
9. üñîçøðé​​@üñîçøðé​​.com（域部分的Unicode字符）
10. Pelé@example.com（拉丁文）
11. δοκιμή@παράδειγμα.δοκιμή（希腊语）
12. 我买@屋企.香港（中文）
13. 甲斐@黒川.日本（日语）
14. чебурашка@ящик-с-апельсинами.рф（西里尔文）

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

于 2015-09-21T01:52:30.870 回答
118

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

function validateEmail(value) {
  var input = document.createElement('input');

  input.type = 'email';
  input.required = true;
  input.value = value;

  return typeof input.checkValidity === 'function' ? input.checkValidity() : /\S+@\S+\.\S+/.test(value);
}

我在小提琴http://jsfiddle.net/boldewyn/2b6d5/中整理了一个示例。结合Squirtle's Answer中的特征检测和基本验证，它可以让您摆脱正则表达式大屠杀，并且不会在旧浏览器上出现问题。

于 2012-12-20T15:20:53.650 回答
81

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)>)$
于 2008-09-05T16:13:15.063 回答
78

这是正确的 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);
}
于 2013-04-15T13:31:28.660 回答
76

符合 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: 最后一个点之后应该有足够的字符来形成一个两个字符的域。我不确定括号是否必要。

于 2011-03-02T11:26:02.337 回答
74

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

email.includes('@')

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

email.indexOf('@') > 0

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

要对此进行测试，请发送验证消息。

于 2013-07-14T18:15:44.523 回答
70

这是从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;}
于 2009-05-02T17:19:46.360 回答
63

做这个：

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

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

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标准中，此处省略。

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

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

于 2012-11-01T14:06:27.477 回答
47

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

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

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

传递Wikipedia Email Address中的示例。

你可以在这里看到结果。

在此处输入图像描述

于 2016-07-01T04:43:18.483 回答
28

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

<input type="email"/>

无需编写验证函数。

于 2013-06-25T06:30:16.977 回答
27

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

现在，由于您只能涵盖 90% 的情况，请编写如下内容：

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

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

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

于 2011-12-19T18:39:02.510 回答
22

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

一些需要改进的地方：

而不是 new RegExp，只需尝试regexp像这样写出：

if (reg.test(/@/))

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

于 2009-05-02T17:23:03.153 回答
18

这就是节点验证器的做法：

/^(?:[\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])\]))$/
于 2013-09-11T02:21:40.317 回答
15

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

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

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

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

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

于 2016-12-28T02:51:37.780 回答
15

维基百科标准邮件语法：

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

功能 ：

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

有效邮件：

validMail('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

无效邮件：

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

于 2017-06-21T09:10:18.750 回答
14

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

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
}
于 2013-11-29T12:26:14.213 回答
14

正则表达式更新 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');
}

打字稿版本完成

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

于 2018-02-06T20:42:09.463 回答
13

与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'); }
于 2012-06-05T23:41:59.357 回答
13 

var testresults

function checkemail() {
  var str = document.validation.emailcheck.value
  var filter = /^([\w-]+(?:\.[\w-]+)*)@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$/i
  if (filter.test(str))
    testresults = true
  else {
    alert("Please input a valid email address!")
    testresults = false
  }
  return (testresults)
}

function checkbae() {
  if (document.layers || document.getElementById || document.all)
    return checkemail()
  else
    return true
}
<form name="validation" onSubmit="return checkbae()">
  Please input a valid email address:<br />

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

于 2013-01-31T09:39:59.967 回答
13

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

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

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
于 2013-04-15T11:53:20.503 回答
13

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

[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])+
于 2016-12-22T07:44:49.003 回答
12

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

这是当前的顶级表达式，它与 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
于 2010-05-28T22:05:45.357 回答
12

显然，就是这样：

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

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

于 2010-10-01T09:37:31.117 回答
10

我正在寻找通过所有电子邮件地址测试用例的 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-.]+]*/
于 2017-01-03T05:38:43.997 回答
9

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

于 2018-06-12T12:03:15.417 回答
9

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

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

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

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

于 2020-01-26T19:36:41.707 回答
8

这里的大多数答案都对 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
于 2020-07-07T14:55:36.967 回答
7

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

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

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

于 2013-12-04T10:44:31.880 回答
7

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

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

于 2019-12-27T08:52:53.777 回答
6

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); 
}
于 2012-08-30T15:00:43.250 回答
6

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

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

于 2016-06-27T23:36:35.057 回答
6

这是数千个网站使用的官方 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
于 2018-06-21T12:13:20.660 回答
6

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

function isValidEmail(value) {
    const atLocation = value.lastIndexOf("@");
    const dotLocation = value.lastIndexOf("."); 
    return (
        atLocation > 0 &&
        dotLocation > atLocation + 1 &&
        dotLocation < value.length - 1
    );
};
  • 获取最后一个“@”和最后一个“.”的位置
  • 确保“@”不是第一个字符（前面有一些东西）
  • 确保“。” 在“@”之后，并且它们之间至少有一个字符
  • 确保“。”之后至少有一个字符。

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

于 2020-02-03T15:38:01.223 回答
5

这是我用于前端电子邮件验证的功能。（正则表达式来自 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>
于 2014-08-04T18:33:58.627 回答
5

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

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

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

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

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

于 2015-09-06T06:31:56.710 回答
4

以下正则表达式验证：

  • @ 之前没有空格字符
  • (-) 和 (.) 不能在 @ 之后在一起 @ 之后没有特殊字符 @ 之前必须有 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;
}
}
于 2015-03-02T07:19:21.370 回答
4

使用正则表达式：

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

它应该只允许 @ , 。, _

于 2016-05-31T08:30:22.787 回答
4

你也可以试试

var string = "hmharsh3@gmail.com"
var exp = /(\w(=?@)\w+\.{1}[a-zA-Z]{2,})/i
alert(exp.test(string))
于 2017-07-22T03:33:13.930 回答
4

您可以使用这个正则表达式（来自w3resource (*not related to W3C)）：

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

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

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

于 2020-01-24T17:32:27.673 回答
3

如果您使用 Closure，您可以使用内置goog.format.EmailAddress类型：

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

例如：

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

请注意，通过阅读源代码（上面链接），您可以看到评论指出 IDN 不受支持，并且它仅旨在涵盖大多数地址：

// This is a fairly naive implementation, but it covers 99% of use cases.
// For more details, see http://en.wikipedia.org/wiki/Email_address#Syntax
// TODO(mariakhomenko): we should also be handling i18n domain names as per
// http://en.wikipedia.org/wiki/Internationalized_domain_name
于 2013-09-10T12:37:10.873 回答
3 
<pre>
**The personal_info part contains the following ASCII characters.
1.Uppercase (A-Z) and lowercase (a-z) English letters.
2.Digits (0-9).
3.Characters ! # $ % & ' * + - / = ? ^ _ ` { | } ~
4.Character . ( period, dot or fullstop) provided that it is not the first or last character and it will not come one after the other.**
</pre>
*Example of valid email id*
<pre>
yoursite@ourearth.com
my.ownsite@ourearth.org
mysite@you.me.net
xxxx@gmail.com
xxxxxx@yahoo.com
</pre>
<pre>
xxxx.ourearth.com [@ is not present] 
xxxx@.com.my [ tld (Top Level domain) can not start with dot "." ]
@you.me.net [ No character before @ ]
xxxx123@gmail.b [ ".b" is not a valid tld ]
xxxx@.org.org [ tld can not start with dot "." ]
.xxxx@mysite.org [ an email should not be start with "." ]
xxxxx()*@gmail.com [ here the regular expression only allows character, digit, underscore and dash ]
xxxx..1234@yahoo.com [double dots are not allowed
</pre>
**javascript mail code**

    function ValidateEmail(inputText)
    {
    var mailformat = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
    if(inputText.value.match(mailformat))
    {
    document.form1.text1.focus();
    return true;
    }
    else
    {
    alert("You have entered an invalid email address!");
    document.form1.text1.focus();
    return false;
    }
    }
于 2014-01-28T05:40:07.967 回答
3

最好的一个：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]));
}
于 2015-08-12T16:58:52.080 回答
3

如果您使用的是 ng-pattern 和材料，则可以完成这项工作。

vm.validateEmail = '([a-zA-Z0-9_.]{1,})((@[a-zA-Z]{2,})[\\\.]([a-zA-Z]{2}|[a-zA-Z]{3}))';
于 2016-07-23T17:11:02.700 回答
3

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

于 2019-01-11T20:04:26.973 回答
3

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

那么这就是你要找的东西。此解决方案不受“正则表达式拒绝服务 (ReDoS)”的影响

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

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

请让我知道此解决方案是否适合您。谢谢。

于 2020-04-13T00:46:58.257 回答
3

找到了完美的正则表达式。它不包括双@，两个“。” 在一行中，除英语以外的语言和行首的额外字符（“.”、“-”、“!”等）

const regexp = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
if (!this.value.match(regexp)) {
// on error, we get into the condition
    this.classList.add('error');
}
// this - email input
于 2021-12-09T19:53:58.660 回答
2

以下正则表达式验证：

  • @ 之前没有空格字符
  • (-) 和 (.) 不应该在 @ 之后在一起
  • @ 后无特殊字符 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;
    }
}
于 2015-03-02T07:21:02.640 回答
2

谁在使用@pvl 解决方案并希望它通过ESLint Prefer-template那么这是一个我使用模板文字而不是字符串连接的版本。

validateEmail(email) {
    let sQtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]';
    let sDtext = '[^\\x0d\\x5b-\\x5d\\x80-\\xff]';
    let sAtom = '[^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-\\x3c\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+';
    let sQuotedPair = '\\x5c[\\x00-\\x7f]';
    let sDomainLiteral = `\\x5b(${sDtext}|${sQuotedPair})*\\x5d`;
    let sQuotedString = `\\x22(${sQtext}|${sQuotedPair})*\\x22`;
    let sDomainRef = sAtom;
    let sSubDomain = `(${sDomainRef}|${sDomainLiteral})`;
    let sWord = `(${sAtom}|${sQuotedString})`;
    let sDomain = `${sSubDomain}(\\x2e${sSubDomain})*`;
    let sLocalPart = `${sWord}(\\x2e${sWord})*`;
    let sAddrSpec = `${sLocalPart}\\x40${sDomain}`; // complete RFC822 email address spec
    let sValidEmail = `^${sAddrSpec}$`; // as whole string

    let reValidEmail = new RegExp(sValidEmail);

    return reValidEmail.test(email);
}
于 2016-11-07T21:21:07.257 回答
2

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

使用 npm install 验证器安装库

var validator = require('validator');

validator.isEmail('foo@bar.com'); //=> true
于 2017-02-13T06:04:30.070 回答
2

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

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

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

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

希望这可以帮助。

于 2017-04-06T04:27:41.870 回答
2

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

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

并检查它是否像下面这样的电子邮件：

isEmail('alex@example.com'); //true
isEmail('alireza@test.co.uk'); //true
isEmail('peter.example@yahoo.com.au'); //true
isEmail('alex@example.com'); //true
isEmail('peter_123@news.com'); //true
isEmail('hello7___@ca.com.pt'); //true
isEmail('example@example.co'); //true
isEmail('hallo@example.coassjj#sswzazaaaa'); //false
isEmail('hallo2ww22@example....caaaao'); //false
于 2017-06-17T06:55:44.140 回答
2

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);
于 2017-07-09T13:05:15.093 回答
2

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

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

于 2018-02-28T00:18:21.533 回答
2

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

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

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

为什么？根据 RFC： https ://en.wikipedia.org/wiki/Email_address#RFC_specification 。

我将摘录一段以方便讲座：

The local-part of the email address may use any of these ASCII characters:

- uppercase and lowercase Latin letters A to Z and a to z;
- digits 0 to 9;
- special characters !#$%&'*+-/=?^_`{|}~;
- dot ., provided that it is not the first or last character unless quoted, and provided also that it does not appear consecutively unless quoted (e.g. John..Doe@example.com is not allowed but "John..Doe"@example.com is allowed);[6]
Note that some mail servers wildcard local parts, typically the characters following a plus and less often the characters following a minus, so fred+bah@domain and fred+foo@domain might end up in the same inbox as fred+@domain or even as fred@domain. This can be useful for tagging emails for sorting, see below, and for spam control. Braces { and } are also used in that fashion, although less often.
- space and "(),:;<>@[\] characters are allowed with restrictions (they are only allowed inside a quoted string, as described in the paragraph below, and in addition, a backslash or double-quote must be preceded by a backslash);
- comments are allowed with parentheses at either end of the local-part; e.g. john.smith(comment)@example.com and (comment)john.smith@example.com are both equivalent to john.smith@example.com.

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

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

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

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

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

怎么处理，那么？

用户是否在几乎所有情况下都添加了无效的电子邮件并不重要。您可以依赖在RFC附近运行的 HTML 5 input type="email"，失败的可能性很小。HTML5 输入类型="email" 信息：https ://www.w3.org/TR/2012/WD-html-markup-20121011/input.email.html

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

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

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

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

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

于 2018-05-28T16:02:31.553 回答
2

通用电子邮件正则表达式（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,}))$/
于 2019-04-25T14:46:18.663 回答
2

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

于 2019-05-27T09:54:58.430 回答
2

我添加了我的正​​则表达式 - 我为我解决了更多的小问题，比如来自其他语言的字符或大写字母

^[a-zA-Z0-9][a-zA-Z0-9-_\.]+@([a-zA-Z]|[a-zA-Z0-9]?[a-zA-Z0-9-]+[a-zA-Z0-9])\.[a-zA-Z0-9]{2,10}(?:\.[a-zA-Z]{2,10})?$
于 2019-08-05T16:23:31.063 回答
2

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

function validEmail(email=''){
    var $0, url, isValid = false, emailPatternInput = /^[^@]{1,64}@[^@]{4,253}$/, emailPatternUrl = /^[^@]{1,64}@[a-z][a-z0-9\.-]{3,252}$/i;
    email = email.trim();
    try{
        url = new URL('http://'+email);
        $0 = `${url.username}@${url.hostname}`;
        isValid = emailPatternInput.test( email );
        if(!isValid) throw 'invalid email pattern on input:' + email;
        isValid = emailPatternUrl.test( $0 );
        if(!isValid) throw 'invalid email pattern on url:' + $0;
        console.log(`email looks legit "${email}" checking url-parts: "${$0 === email ? '-SAME-':$0}"`);
    }catch(err){
        console.error(`probably not an email address: "${email}"`, err);
    };
    return isValid;
}

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

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

另请参阅 MDN URL 文档URL、window.URL和 Nodejs 以获取URL API。

于 2019-09-17T03:00:32.020 回答
2

你可以试试RegExp

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

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

于 2019-11-26T10:09:08.540 回答
1

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

https://docs.angularjs.org/api/ng/input/input%5Bemail%5D

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

var isEmail = $compile('<input ng-model="m" type="email">')($rootScope.$new()).
    controller('ngModel').$validators["email"];

if (isEmail('email@gmail.com')) {
  console.log('valid');
}
于 2014-12-15T01:21:12.163 回答
1

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

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

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

function doesEmailExist(email) {
    var emailExistence = require('email-existence');
    return emailExistence.check(email,function (err,status) {
            if (status) {
                return status;
            }
            else {
                throw new Error('Email does not exist');
            }
        });
}
于 2015-02-18T08:33:51.163 回答
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"});
于 2015-08-25T14:24:45.330 回答
1

此正则表达式可防止重复域名，如 abc@abc.com.com.com.com，它只允许域两次，如 abc@abc.co.in。它也不允许从像 123abc@abc.com 这样的数字开始 

regexp: /^([a-zA-Z])+([a-zA-Z0-9_.+-])+\@(([a-zA-Z])+\.+?(com|co|in|org|net|edu|info|gov|vekomy))\.?(com|co|in|org|net|edu|info|gov)?$/,

祝一切顺利 ！！！！！

于 2015-11-03T07:46:49.387 回答
1

我想添加一个关于非 ASCII 字符的简短说明。Rnevius (and co.) 的解决方案非常出色，但它允许添加可能受某些服务器限制的西里尔文、日文、表情符号和其他 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'))

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

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

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

于 2017-06-02T07:52:09.293 回答
1 
 <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>
于 2018-02-27T09:56:15.607 回答
1

这是一个有效的解决方案，并在表单中包含验证/通知功能：

您可以在此链接上运行它

JAVASCRIPT

(function() {
  'use strict';

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

HTML

<p class='title'>
    <b>Email validation</b>
  <hr size="30px;">
</p>
<br>

<form id="needs-validation" novalidate>
  <p class='form_text'>Try it out!</p>
  <div class="form-row">
    <div class="col-12">
      <input type="email" class="form-control" placeholder="Email Address" required>
        <div class="invalid-feedback">
          Please enter a valid email address.
        </div>
    </div>
  <div class="row">
    <div class="col-12">
      <button type="submit" 
          class="btn btn-default btn-block">Sign up now
      </button>
    </div>
   </div>
</form>
于 2018-07-18T10:15:54.970 回答
1

我编写了一个与 PHP 实现完全兼容的 JavaScript 电子邮件验证器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);
于 2018-07-22T10:53:07.337 回答
1

你冷使用https://github.com/chriso/validator.js并简单地做：

var validator = require('validator');

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

请注意，这可以在客户端上运行。

于 2019-01-28T20:49:22.730 回答
1

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

于 2019-02-23T20:19:12.123 回答
1

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

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

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


// Assume 'nicolas@internal.masala.co.uk'
export function simpleEmail() {

    return C.charNotIn(illegalCharset).rep() // 'nicolas'
        .then(C.char('@'))
        .then(subDns())  //'internal.masala.co.'
        .then(C.charNotIn(extendedIllegalCharset).rep()) //'uk'
        .eos(); // Must be end of the char stream
}

// x@internal.masala.co.uk => extract 'internal.masala.co.'
function  subDns() {
    return C.charNotIn(extendedIllegalCharset).rep().then(C.char('.')).rep()
}

function validateEmail(email:string) {
    console.log(email + ': ' + (simpleEmail().parse(Streams.ofString(email)).isAccepted()));
}


validateEmail('nicolas@internal.masala.co.uk'); // True
validateEmail('nz@co.'); // False, trailing "."

如果您想接受终极丑陋的电子邮件版本，您可以在第一部分添加引号：


function inQuote() {
    return C.char('"')
        .then(C.notChar('"').rep())
        .then(C.char('"'))
}

function allEmail() {

    return inQuote().or(C.charNotIn(illegalCharset))
        .rep() // repeat (inQuote or anyCharacter)
        .then(C.char('@'))
        .then(subDns())
        .then(C.charNotIn(extendedIllegalCharset).rep())
        .eos() // Must be end of the character stream
        // Create a structure
        .map(function (characters) { return ({ email: characters.join('') }); });
}

'"nicolas""love-quotes"@masala.co.uk'是正式有效的，但它应该在你的系统中吗？

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

于 2019-06-05T10:14:43.787 回答
1

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

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

于 2019-11-17T22:22:24.797 回答
1 
     // 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>
于 2020-11-08T07:09:50.150 回答
1

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

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

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

于 2021-04-14T09:42:00.770 回答
1

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

anythingExceptAtOrSpace@anythingExceptAtOrSpace.anythingExceptAtOrSpace

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

去测试：

const emailRegex = /^[^@ ]+@[^@ ]+\.[^@ ]+$/
const result1 = emailRegex.test('hello@there.com')
console.log(result1) // true
const result2 = emailRegex.test('hel@lo@there.com')
console.log(result2) // false

于 2021-04-18T01:01:20.513 回答
1 
// Try this regular Expression by ES6 function

const emailValidate = (email) => {
  const regexp= /^[\w.%+-]+@[\w.-]+\.[\w]{2,6}$/;
  return regexp.test(email);
}
于 2021-04-28T06:43:53.257 回答
0

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

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, '');
    };
}
于 2014-07-11T18:36:33.330 回答
0 
\b[a-z][\w\d_\.]+@\w+\.[a-z]{2}[a-z]?\.?[a-z]{,2}\s

它允许：

abcxyz123@qwert.com    
abc123xyz@asdf.co.in   
abc1_xyz1@gmail1.com   
abc.xyz@gmail.com.in
于 2015-07-09T08:19:19.227 回答
0

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

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

var pattern = /^\w+@[a-zA-Z_]+?\.[a-zA-Z]{2,3}$/;
于 2017-03-18T07:57:11.240 回答
0

现在 ReactNative 版本 0.46 使用下面的代码进行电子邮件验证。

 validateEmail = (email) => {
     var re = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
     if (re.test(email)) {
     } else {
       alert('email: ' + "Please enter valid emailID.")
     }
 }
于 2017-07-13T10:28:38.877 回答
0

有我的电子邮件验证器版本。此代码使用面向对象编程完成，并作为具有静态方法的类实现。您会发现两个版本的验证器：strict( EmailValidator.validate) 和 kind( 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}.`);
else
    console.log(`Email is invalid: ${email}.`);
于 2019-03-01T16:27:40.910 回答
0

我正在使用这个功能

/**
 * @param {*} email
 */
export const validateEmail = email => {
    return new RegExp(/[\w-]+@([\w-]+\.)+[\w-]+/gm).test(email);
};
于 2019-04-23T08:43:49.027 回答
0

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

function validateEmail(email){
        var reg = /^([A-Za-z0-9_\-\.])+\@([A-Za-z0-9_\-\.])+\.([A-Za-z]{2,4})$/;

       //your custom code here to check your email address 

}
于 2019-11-04T04:41:12.323 回答
0

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

于 2021-07-02T07:29:57.023 回答
-1 
function ValidateEmail(mail) 
{
  if (/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(myForm.emailAddr.value))
  {
    return (true)
  }
  alert("You have entered an invalid email address!")
  return (false)
}

参考网址：https ://www.w3resource.com/javascript/form/email-validation.php

于 2018-08-21T13:50:45.570 回答
-1

这对我有用：

function Email(mail)
{
 if (/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(myForm.emailAddr.value))
  {
    return (true)
  }
    alert("Invalid email address!")
    return (false)
}
于 2018-09-08T11:41:54.470 回答
-2

personal_info 部分包含以下 ASCII 字符。

  1. 大写 (AZ) 和小写 (az) 英文字母。数字 (0-9)。
  2. 人物 ！# $ % & ' * + - / = ? ^ _ ` { | } ~
  3. 特点 。（句点、点或句号）前提是它不是第一个或最后一个字符，并且不会一个接一个出现。

域名 [例如 com、org、net、in、us、info] 部分包含字母、数字、连字符和点。

 function ValidateEmail(mail) 
{
 if (/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(myForm.emailAddr.value))
  {
    return (true)
  }
    alert("You have entered an invalid email address!")
    return (false)
}
于 2018-11-19T15:33:56.543 回答
-2

你也可以使用RegExp：

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

有关更多信息，请参阅MDN 上的正则表达式指南。

于 2018-12-12T18:05:03.773 回答
-2

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

function validaEmail(email){

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

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

  }

  return false;
  
}
于 2021-05-20T14:33:32.713 回答
-3

中很简单JavaScript。遵循此代码。

function validate(){
    var email = document.getElementById('Email');
    var filter = /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/;

    if (!filter.test(email.value))
    {
        alert('Please Enter the valid email address');
        email.focus;
        return false;
    }
    else
{
        return true;
    }

HTML代码：

form name="form"
     enctype="multipart/form-data"
     name="form"
     action="register.php"
     method="POST" onsubmit="return validate();" >
    <input type="text" placeholder="Enter ur Email Id" id="Email" name="Email" />
    <input type="submit" id="submit" value="save" name="Like" class="button" />
</form>
于 2014-02-26T10:49:21.830 回答
-4

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

 String EMAIL_PATTERN ="^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$";
于 2015-12-30T14:48:29.880 回答
-5 
function validatecontactEmail(email) { 

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

    return (false)  

}
于 2014-07-17T14:39:28.267 回答
-6

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

function validateEmail(email) {
    var atpos=email.indexOf("@");
    var dotpos=email.lastIndexOf(".");
    if (atpos < 1 || dotpos < atpos+2 || dotpos+2 >= email.length) {
        alert("Not a valid e-mail address");
        return false;
    }
    return true;
}

请注意，如果有空格，则必须删除空格，如下所示：

.replace(/ /g,'')

来源：JavaScript 表单验证

于 2013-10-31T23:23:46.313 回答
-6

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

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

if(email=="") {
    window.plugins.toast.showShortBottom( "Please enter the details. ", function(a) {
        console.log('toast success: ' + a);
    }, function(b) { });
} else if(!rex_email.test(email)) {
    window.plugins.toast.showShortBottom( "Please enter the valid email id. ", function(a) {
        console.log('toast success: ' + a);
    }, function(b) { });
}
于 2015-01-21T00:20:54.117 回答
-7

以下正则表达式：

/^([\w]+)(.[\w]+)*@([\w]+)(.[\w]{2,3}){1,2}$/;
于 2009-05-02T17:20:09.213 回答
-7 
function validateEmail(elementValue){        
    var emailPattern = /^[a-zA-Z0-9._]+[a-zA-Z0-9]+@[a-zA-Z0-9]+\.[a-zA-Z]{2,4}$/;  
    return emailPattern.test(elementValue);   
  }

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

于 2012-10-15T11:01:33.870 回答