Como validar um endereço de e-mail em JavaScript?

StackOverflow https://stackoverflow.com/questions/46155

Pergunta

Como um endereço de e-mail pode ser validado em JavaScript?

Foi útil?

Solução

Usando expressões regulares é provavelmente a melhor maneira.Você pode ver vários testes aqui (Tirado de cromo)

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

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

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

Mas tenha em mente que não se deve confiar apenas na validação do JavaScript.JavaScript pode ser facilmente desativado.Isso também deve ser validado no lado do servidor.

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

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

function validate() {
  var $result = $("#result");
  var email = $("#email").val();
  $result.text("");

  if (validateEmail(email)) {
    $result.text(email + " is valid :)");
    $result.css("color", "green");
  } else {
    $result.text(email + " is not valid :(");
    $result.css("color", "red");
  }
  return false;
}

$("#validate").on("click", validate);
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

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

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

Outras dicas

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 e-mail válidos devem seguir.Você pode (mas você não deveria — Leia) implemente-o 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])+)\])

(...) Obtemos uma implementação mais prática da RFC 2822 se omitirmos a sintaxe usando aspas duplas e colchetes. Ele ainda corresponderá a 99,99% de todos os endereços de e-mail em uso atualmente.

[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 de duas letras e apenas domínios genéricos de nível superior específicos. Este regex filtra endereços de e-mail fictícios como asdf@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á compensações a serem feitas. Não copie cegamente expressões regulares de bibliotecas on-line ou fóruns de discussão.Sempre teste-os com seus próprios dados e com seus próprios aplicativos.

Ênfase minha

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

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

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 detecta os erros mais óbvios que o usuário comete e garante que o formulário está correto, e é disso que se trata a validação de JavaScript.

Há algo que você precisa entender no segundo em que decide usar uma expressão regular para validar e-mails: Provavelmente não é uma boa ideia.Depois de aceitar isso, existem muitas implementações por aí que podem levar você a meio caminho, este artigo os resume muito bem.

Resumindo, porém, a única maneira de ter certeza absoluta e positiva de que o que o usuário digitou é de fato um e-mail é enviar um e-mail e ver o que acontece.Fora isso, são apenas suposições.

O próprio HTML5 possui validação de e-mail.Se o seu navegador suportar HTML5, você poderá usar o código a seguir.

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

jsFiddle link

De Especificação HTML5:

A Endereço de Email Válido é uma string que corresponde ao email produção do seguinte ABNF, 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 >

Este requisito é um violação intencional da RFC 5322, que define uma sintaxe para endereços de e-mail que é simultaneamente muito rígida (antes do caractere "@"), muito vaga (após o caractere "@") e muito frouxa (permitindo comentários, caracteres de espaço em branco e citações strings de maneiras desconhecidas para a maioria dos usuários) para serem de uso prático 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.  disposable.style.email.with+symbol@example.com
4.  other.email-with-dash@example.com
9.  #!$%&'*+-/=?^_`{}|~@example.org
6.  "()[]:,;@\\\"!#$%&'*+-/=?^_`{}| ~.a"@example.org
7.  " "@example.org (space between the quotes)
8.  üñîçøðé@example.com (Unicode characters in local part)
9.  üñîçøðé@üñîçøðé.com (Unicode characters in domain part)
10. Pelé@example.com (Latin)
11. δοκιμή@παράδειγμα.δοκιμή (Greek)
12. 我買@屋企.香港 (Chinese)
13. 甲斐@黒川.日本 (Japanese)
14. чебурашка@ящик-с-апельсинами.рф (Cyrillic)

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

Em navegadores modernos, você pode desenvolver a resposta do @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);
}

Eu montei um exemplo no violino http://jsfiddle.net/boldewyn/2b6d5/.Combinado com a detecção de recursos e a validação básica de Resposta de Squirtle, ele liberta você do massacre de expressões regulares e não funciona em navegadores antigos.

JavaScript pode corresponder a uma expressão regular:

emailAddress.match( / some_regex /);

Aqui está um RFC22 expressão regular 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)>)$

Esta é a versão RFC822 correta.

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

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

email.indexOf("@") > 0

Não se preocupe com nada mais complicado.Mesmo que você pudesse determinar perfeitamente se um e-mail é sintaticamente válido em termos de RFC, isso não lhe diria 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 em PHP é O que é um endereço de e-mail válido?.Obviamente, foi portado para Java. 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 verificar novamente a validação no servidor.Com isso em mente, você pode simplesmente verificar se uma string se parece com um endereço de e-mail válido no cliente e realizar a verificação rigorosa no servidor.

Aqui está a função JavaScript que uso para verificar se uma string se parece com um endereço de e-mail 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:Durar @ deveria ser penúltimo . desde @ não pode fazer parte do nome do servidor (até onde eu sei).

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

  • str.indexOf('@@') == -1:Não deveria haver @@ no endereço.Ainda que @ aparece como o último caractere no nome de usuário do e-mail, deve ser citado para " estaria entre isso @ 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.

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

Estou realmente ansioso para resolver esse problema.Então modifiquei a expressão regular de validação de e-mail 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 em Endereço de e-mail da Wikipédia.

E você pode ver o resultado em aqui.

enter image description here

Fazem isto:

[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 que? É baseado em RFC 2822, que é um padrão que TODOS os endereços de e-mail DEVEM aderir.E não sei por que você se preocuparia com algo "mais simples"...você vai copiar e colar de qualquer maneira ;)

Freqüentemente, ao armazenar endereços de e-mail no banco de dados, eu os deixo em letras minúsculas e, na prática, as regexs geralmente podem ser marcadas sem distinção entre maiúsculas e 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 i no 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') );

Observação:
Tecnicamente, alguns e-mails podem incluir citações na seção anterior ao @ símbolo com caracteres de escape entre aspas (para que seu usuário de e-mail possa ser desagradável e conter coisas como @ e "..." desde que esteja escrito entre aspas).NINGUÉM FAZ ISSO NUNCA!Está obsoleto.Mas, ESTÁ incluído no verdadeiro RFC 2822 padrão e omitido aqui.

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

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

Agora, como você só pode cobrir 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 a essência.E não se empolgue...Uma solução simples de 90% é melhor do que uma solução 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 usando HTML.

<input type="email"/>

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

É assim 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])\]))$/

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

Algumas coisas para melhorar:

Em vez de novo RegExp, tente escrever o regexp sai assim:

if (reg.test(/@/))

Em segundo lugar, verifique se a menstruação vem depois do @ sinal e certifique-se de que haja caracteres entre o @se períodos.

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

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

Melhor regex de todos os tempos que está em conformidade com o RFC5322

[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 solução que não verifica a existência do TLD está incompleta.

Quase todas as respostas a essas perguntas sugerem o uso de Regex para validar endereços de e-mail.Acho que Regex só serve para uma validação rudimentar.Parece que a verificação da validação de endereços de e-mail é, na verdade, dois problemas distintos:

1- Validação do formato do email: Certificar-se de que o e-mail está em conformidade com o formato e padrão de e-mails da 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 vai passar a regex, não é um email válido, pois ccc não é um domínio de nível superior da IANA.

2- Certificando-se de que o e-mail realmente existe: Para fazer isso, a única opção é para enviar um e-mail aos usuários.

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

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

Mas, claro, isso é ignorar a internacionalização.

Em contraste com esguicho, aqui está uma solução complexa, mas que faz um excelente trabalho de validação de e-mails 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'); }

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

Aqui está a expressão principal 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

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

Os erros mais comuns que encontrei são espaços (especialmente no início e no final) 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>

A expressão regular fornecida pela Microsoft em 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 posto aqui caso tenha alguma falha - embora sempre tenha sido perfeito para minhas necessidades.

Sintaxe de correio padrão da Wikipedia:

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

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

// VALID MAILS

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

// INVALID MAILS

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

Mostre este teste: https://regex101.com/r/LHJ9gU/1

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top