Como validar um endereço de email em JavaScript

Existe uma expressão regular para validar um endereço de email em JavaScript?

Usar expressões regulares é provavelmente o melhor caminho. Você pode ver vários testes aqui (extraídos do cromo )

function validateEmail(email) {
    const 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());
}

Aqui está o exemplo de expressão regular que aceita unicode:

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

Mas lembre-se de que não se deve confiar apenas na validação do JavaScript. JavaScript pode ser facilmente desativado. Isso também deve ser validado no servidor.

Aqui está um exemplo do acima em ação:

function validateEmail(email) {
  const 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() {
  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;
}

$("#validate").on("click", validate);

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

<form>
  <p>Enter an email address:</p>
  <input id='email'>
  <button type='submit' id='validate'>Validate!</button>
</form>

<h2 id='result'></h2>

Modifiquei levemente a resposta de Jaymon para pessoas que desejam uma validação realmente simples na forma de:

anystring@anystring.anystring

A expressão regular:

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

Exemplo de função JavaScript:

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

Apenas para completar, aqui você tem outro regex compatível com RFC 2822

O padrão oficial é conhecido como RFC 2822 . Ele descreve a sintaxe que os endereços de email válidos devem aderir. Você pode ( mas não deve - continue a ler ) implementá-lo com esta expressão regular:

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

(...) Obteremos uma implementação mais prática da RFC 2822 se omitirmos a sintaxe usando aspas duplas e colchetes. Ainda corresponderá a 99,99% de todos os endereços de email em uso real hoje.

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

Uma outra alteração que você pode fazer é permitir qualquer domínio de nível superior com código de país com duas letras e apenas domínios de nível superior genérico específicos. Este regex filtra endereços de email falsos comoasdf@adsf.adsf . Você precisará atualizá-lo à medida que novos domínios de nível superior forem adicionados .

[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

Portanto, mesmo seguindo os padrões oficiais, ainda há compromissos a serem feitos. Não copie cegamente expressões regulares de bibliotecas online ou fóruns de discussão. Sempre teste-os com seus próprios dados e com seus próprios aplicativos.

_{Mina de ênfase}

Uau, há muita complexidade aqui. Se tudo o que você deseja fazer é capturar os erros de sintaxe mais óbvios, eu faria algo assim:

^\S+@\S+$

Geralmente, ele captura os erros mais óbvios que o usuário comete e garante que o formulário esteja correto, o que é a validação do JavaScript.

Há algo que você precisa entender no segundo em que decide usar uma expressão regular para validar emails: provavelmente não é uma boa ideia . Depois que você concorda com isso, existem muitas implementações por aí que podem levá-lo até o meio do caminho, este artigo as resume muito bem.

Em resumo, no entanto, a única maneira de ter certeza absoluta e positiva de que o que o usuário digitou é de fato um email é realmente enviar um email e ver o que acontece. Fora isso, são apenas suposições.

O próprio HTML5 possui validação de email. Se o seu navegador suportar HTML5, você poderá usar o seguinte código.

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

jsFiddle link

A partir da especificação HTML5 :

Um endereço de email válido é uma sequência que corresponde à emailprodução do ABNF a seguir, cujo conjunto de caracteres é 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 >

Esse requisito é uma violação intencional do RFC 5322, que define uma sintaxe para endereços de email que são simultaneamente muito rígidos (antes do caractere "@"), muito vagos (após o caractere "@") e muito relaxados (permitindo comentários) , caracteres de espaço em branco e seqüências de caracteres citadas de maneiras não familiares à maioria dos usuários) para serem úteis aqui.

A seguinte expressão regular compatível com JavaScript e Perl é uma implementação da definição acima.

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

Eu descobri que esta é a melhor solução:

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

Permite os seguintes formatos:

1. prettyandsimple@example.com
2. very.common@example.com
3. descartable.style.email.com+symbol@example.com
4. other.email-with-dash@example.com
9. #!$%&'*+-/=?^_`{}|~@example.org
6. "() []:,; @ \\\"! # $% & '* + - / =? ^ _ `{} | ~ .a "@ example.org
7. "" @ example.org (espaço entre as aspas)
8. üñîçøðé@example.com (caracteres Unicode na parte local)
9. üñîçøðé@üñîçøðé.com (caracteres Unicode na parte do domínio)
10. Pelé@example.com (latino)
11. δοκιμή@παράδειγμα.δοκιμή (grego)
12. 我 買 @ 屋企. 香港 (chinês)
13. 甲 斐 @ 黒 川. 日本 (japonês)
14. чебурашка@ящик-с-апельсинами.рф (cirílico)

É claramente versátil e permite todos os caracteres internacionais importantes, ao mesmo tempo em que aplica o formato básico everything@anything.anything. Ele bloqueará espaços tecnicamente permitidos pela RFC, mas são tão raros que fico feliz em fazer isso.

Nos navegadores modernos, você pode criar sobre a resposta da @ Sushil com JavaScript puro e o DOM :

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

Reuni um exemplo no violino http://jsfiddle.net/boldewyn/2b6d5/ . Combinado com a detecção de recursos e a validação básica do Squirtle's Answer , ele o libera do massacre de expressões regulares e não funciona em navegadores antigos.

Esta é a versão correta do 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);
}

JavaScript pode corresponder a uma expressão regular:

emailAddress.match( / some_regex /);

Aqui está uma expressão regular RFC22 para e-mails:

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

Todos os endereços de email contêm um símbolo 'at' (ou seja, @). Teste essa condição necessária:

email.indexOf("@") > 0

Não se preocupe com algo mais complicado. Mesmo se você pudesse determinar perfeitamente se um email é sintaticamente válido para RFC, isso não informaria se ele pertence à pessoa que o forneceu. Isso é o que realmente importa.

Para testar isso, envie uma mensagem de validação.

A validação correta do endereço de email em conformidade com as RFCs não é algo que pode ser alcançado com uma expressão regular de uma linha. Um artigo com a melhor solução que encontrei no PHP é O que é um endereço de email válido? . Obviamente, foi portado para Java. Eu acho que a função é muito complexa para ser portada e usada em JavaScript. Porta JavaScript / node.js: https://www.npmjs.com/package/email-addresses .

Uma boa prática é validar seus dados no cliente, mas verifique novamente a validação no servidor. Com isso em mente, você pode simplesmente verificar se uma string se parece com um endereço de email válido no cliente e executar uma verificação rigorosa no servidor.

Aqui está a função JavaScript que eu uso para verificar se uma string se parece com um endereço de email válido:

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

Explicação:

• lastAtPos < lastDotPos: Last @deve ser antes de last, .pois @não pode fazer parte do nome do servidor (tanto quanto eu sei).

• lastAtPos > 0: Deve haver algo (o nome de usuário do email) antes do último @.

• str.indexOf('@@') == -1: Não deve haver nenhum @@endereço. Mesmo que @apareça como o último caractere no nome de usuário do e-mail, ele deve ser citado, pois "estaria entre esse @e o último @no endereço.

• lastDotPos > 2: Deve haver pelo menos três caracteres antes do último ponto, por exemplo a@b.com.

• (str.length - lastDotPos) > 2: Deve haver caracteres suficientes após o último ponto para formar um domínio de dois caracteres. Não tenho certeza se os colchetes são necessários.

Isso foi roubado de 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;}

Faça isso:

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

Por quê? É baseado na RFC 2822 , que é um padrão que TODOS os endereços de e-mail DEVEM aderir. E não sei por que você se incomodaria com algo "mais simples" ... você vai copiar e colar mesmo assim;)

Freqüentemente, ao armazenar endereços de email no banco de dados, eu os deixo em minúsculas e, na prática, as regexs geralmente podem ser marcadas como não diferenciando maiúsculas de minúsculas. Nesses casos, isso é um pouco mais curto:

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

Aqui está um exemplo dele sendo usado em JavaScript (com o sinalizador que não diferencia maiúsculas de minúsculas ino final).

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

Nota :
tecnicamente, alguns emails podem incluir aspas na seção antes do @símbolo com caracteres de escape dentro das aspas (para que o usuário do email possa ser desagradável e conter itens como @e "..."contanto que esteja escrito entre aspas). NINGUÉM FAZ ISSO NUNCA! É obsoleto. Mas, está incluído no verdadeiro padrão RFC 2822 e é omitido aqui.

Mais informações: http://www.regular-expressions.info/email.html

Estou realmente ansioso para resolver este problema. Então eu modifiquei a expressão regular de validação de email acima

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

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

para passar os exemplos no endereço de e-mail da Wikipedia .

E você pode ver o resultado aqui .

Você não deve usar expressões regulares para validar uma sequência de entrada e verificar se é um email. É muito complicado e não cobriria todos os casos.

Agora, como você pode cobrir apenas 90% dos casos, escreva algo como:

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

Você pode refiná-lo. Por exemplo, 'aaa @' é válido. Mas no geral você entende. E não se deixe levar ... Uma solução simples de 90% é melhor que uma solução de 100% que não funciona.

O mundo precisa de código mais simples ...

Basta verificar se o endereço de e-mail inserido é válido ou não está em HTML.

<input type="email"/>

Não há necessidade de escrever uma função para validação.

É difícil obter um validador de email 100% correto. A única maneira real de corrigi-lo seria enviar um email de teste para a conta. Dito isto, existem algumas verificações básicas que podem ajudar a garantir que você esteja recebendo algo razoável.

Algumas coisas para melhorar:

Em vez de novo RegExp, tente escrever o seguinte regexpdesta maneira:

if (reg.test(/@/))

Segundo, verifique se um ponto vem após o @sinal e verifique se há caracteres entre @s e períodos.

É assim que o validador de nó faz isso:

/^(?:[\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])\]))$/

Use este código dentro da sua função validadora:

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

Caso contrário, você pode usar o jQuery . As regras internas definem:

eMailId: {
    required: true,
    email: true
}

Atualização Regex 2018! tente isso

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

versão typscript concluída

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

mais informações https://git.io/vhEfc

Uma solução que não verifica a existência do TLD está incompleta.

Quase todas as respostas a essas perguntas sugerem o uso do Regex para validar endereços de e-mail. Eu acho que o Regex é bom apenas para uma validação rudimentar. Parece que a verificação de validação de endereços de email é na verdade dois problemas separados:

1- Validação do formato do email: verifique se o email está em conformidade com o formato e o padrão dos emails na RFC 5322 e se o TLD realmente existe. Uma lista de todos os TLDs válidos pode ser encontrada aqui .

Por exemplo, embora o endereço example@example.ccc passe na regex, não é um email válido, porque cccnão é um domínio de nível superior da IANA.

2- Certificando-se de que o email realmente exista: Para isso, a única opção é enviar um email aos usuários .

Regex para validar endereço de 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])+

Aqui está uma discussão muito boa sobre o uso de expressões regulares para validar endereços de email; " Comparando endereço de email validando expressões regulares "

Aqui está a expressão superior atual, compatível com JavaScript, para fins de referência:

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

Aparentemente, é isso:

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

Retirado de http://fightingforalostcause.net/misc/2006/compare-email-regex.php em 1 de outubro de 2010.

Mas, é claro, isso está ignorando a internacionalização.

Ao contrário do squirtle , aqui está uma solução complexa, mas ele faz um excelente trabalho de validação de emails corretamente:

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

Use assim:

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

Meu conhecimento de expressões regulares não é tão bom. É por isso que eu verifico a sintaxe geral com uma expressão regular simples primeiro e depois as opções mais específicas com outras funções. Essa pode não ser a melhor solução técnica, mas dessa maneira eu sou muito mais flexível e mais rápida.

Os erros mais comuns que encontrei são espaços (especialmente no começo e no fim) e, ocasionalmente, um ponto duplo.

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>

Eu estava procurando por um Regex em JS que passasse em todos os casos de teste de endereço de email:

• email@example.com Email válido

• firstname.lastname@example.com O email contém um ponto no campo de endereço

• email@subdomain.example.com O email contém ponto com subdomínio

• firstname+lastname@example.com O sinal de adição é considerado um caractere válido

• email@192.0.2.123 O domínio é um endereço IP válido

• email@[192.0.2.123] O colchete em torno do endereço IP é considerado válido

• “email”@example.com Citações entre e-mail são consideradas válidas

• 1234567890@example.com Os dígitos no endereço são válidos

• email@domain-one.example O traço no nome de domínio é válido

• _______@example.com Sublinhado no campo de endereço é válido

• email@example.name .name é um nome de domínio de nível superior válido

• email@example.co.jpPonto no nome de domínio de nível superior também considerado válido (usando co.jpcomo exemplo aqui)

• firstname-lastname@example.com O traço no campo de endereço é válido

Aqui vamos nós :

http://regexr.com/3f07j

OU regex:

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

A expressão regular fornecida pela Microsoft no ASP.NET MVC é

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

Que eu publico aqui caso seja falha - embora sempre tenha sido perfeita para minhas necessidades.