Como validar um endereço de E-mail em JavaScript?
como é que um endereço de E-mail pode ser validado em JavaScript?
30 answers
Usar expressões regulares é provavelmente a melhor maneira. Você pode ver um monte de 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 expansã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 JavaScript. JavaScript pode ser facilmente desativado. Isto também deve ser validado no lado do servidor.
Aqui está um exemplo do acima em acçã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").bind("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>
Só para ser Completo, aqui tem outro regex compatível com a RFC 2822.
A norma oficial é conhecida como RFC 2822. Descreve a sintaxe a que os endereços de E-mail válidos devem aderir. Podes, mas não devias. - Leia em ) execute - 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 parêntesis rectos. Ainda vai corresponder a 99.99% de todos os endereços de E-mail em uso 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 mudança que você poderia fazer é permitir qualquer domínio de código de país de duas letras de nível superior, e apenas domínios genéricos de nível superior específicos. Esta expressão regular filtra endereços de E-mail falsos como
[email protected]
. O terá de o actualizar à medida que forem adicionados novos domínios de topo.Por isso, mesmo seguindo as normas oficiais, ainda há compromissos a fazer. não copie cegamente expressões regulares de bibliotecas online ou fóruns de discussão. Sempre testá - los em seus próprios dados e com suas próprias aplicações.
[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
Ênfase minha
A expressão regular:
/\S+@\S+\.\S+/
Exemplo de função JavaScript:
function validateEmail(email)
{
var re = /\S+@\S+\.\S+/;
return re.test(email);
}
Há uma coisa que tens de compreender assim que decidires usar uma expressão regular para validar e-mails: provavelmente não é uma boa ideia. Uma vez que você tenha chegado a um acordo com isso, há muitas implementações lá fora que podem levá-lo a meio caminho, este artigo resume-os muito bem.
Em resumo, no entanto, a única maneira de ter a certeza absoluta de que o que o utilizador introduziu é, de facto, enviar um e-mail e ver o que acontece. Tirando isso, são só suposições.\S+@\S+
Ele geralmente pega os erros mais óbvios que o usuário faz e garante que o formulário é principalmente certo, que é o que a validação JavaScript é tudo sobre.
O HTML5 em si tem validação por e-mail. Se o seu navegador suporta HTML5, então você pode usar o seguinte código.
<form><input type="email" placeholder="[email protected]">
<input type="submit">
</form>
Da especificação HTML5:
A endereço de E-mail válido é uma cadeia que corresponde à produção
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 é uma violação intencional da RFC 5322, que define uma sintaxe para endereços de E-mail que é simultaneamente demasiado rigoroso (antes do carácter"@"), demasiado vago (depois do carácter"@"), e demasiado laxista (permitindo comentários, caracteres de espaço em branco, e cadeias de caracteres cotadas de maneiras desconhecidas para a maioria dos utilizadores) para ser 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])?)*$/
Achei esta a melhor solução:
/^[^\s@]+@[^\s@]+\.[^\s@]+$/
Permite os seguintes formatos:
1. [email protected] 2. [email protected] 3. [email protected] 4. [email protected] 9. #!$%&'*+-/=?^_`{}|[email protected] 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 a todos os personagens internacionais importantes, ao mesmo tempo em que continua a aplicar o básico qualquer coisa@qualquer coisa.qualquer formato. Irá bloquear espaços que são tecnicamente permitidos pela RFC, mas são tão raros que fico feliz em fazer isto.
Nos navegadores modernos você pode construir em cima da resposta de @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);
}
Montei um exemplo no violino. http://jsfiddle.net/boldewyn/2b6d5 / . combinado com a detecção de recursos e a validação sem ossos de a resposta do Squirtle, liberta-o do massacre de Expressões Regulares e não bork em navegadores antigos.
O 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)>)$
Esta é a versão correcta 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);
}
A validação correcta do endereço de E-mail em conformidade com os RFCs não é algo que possa ser alcançado com uma expressão regular de uma linha única. Um artigo com a melhor solução que eu 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.
Uma boa prática é validar os seus dados sobre o cliente, mas verifique a validação no servidor. Com isto 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 estrita no servidor.Aqui está a função JavaScript que eu uso para verificar se um texto 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
: o último@
deve ser antes do último.
Uma vez que@
não pode fazer parte do nome do servidor (tanto quanto sei).lastAtPos > 0
: deve haver algo (o nome de utilizador do E-mail) antes the last@
.str.indexOf('@@') == -1
: não deve haver nenhum@@
no endereço. Mesmo que@
apareça como o último carácter no nome de utilizador do E-mail, tem de ser citado assim"
estaria entre esse@
e o último@
no endereço.lastDotPos > 2
: deve haver pelo menos três caracteres antes do último ponto, por exemplo[email protected]
.(str.length - lastDotPos) > 2
: deve haver caracteres suficientes após o último ponto para formar um domínio de dois caracteres. Não tenho a certeza se ... os suportes são necessários.
Todos os endereços de E-mail contêm um símbolo 'at' (isto é,@). Testar a condição necessária:
email.indexOf("@") > 0
Não te preocupes com nada mais complicado. Mesmo que você pudesse determinar perfeitamente se um e-mail é RFC-sintaticamente válido, 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.
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;}
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 Wikipedia Email Address .
E você pode ver o resultado em aqui.
Faz 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])?
Porquê? É baseado na RFC. 2822, que é um padrão a que todos os endereços de E-mail devem aderir.
Muitas vezes, ao armazenar endereços de E-mail na base de dados, faço-os em minúsculas e, na prática, as expressões regulares podem ser marcadas sem distinção de maiúsculas. Nestes casos, esta é ligeiramente mais Curta:
[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 de ser usado em JavaScript (com a bandeira insensível à capitalização i
na 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('[email protected]') );
Nota:
Tecnicamente, alguns e-mails podem incluir aspas na secção antes do símbolo @
com caracteres de escape dentro das aspas (para que o seu utilizador de E-mail possa ser desagradável e conter coisas como @
e "..."
desde que esteja escrito entre aspas). NUNCA NINGUÉM FAZ ISTO! Está obsoleto. Mas, está incluído no verdadeiro padrão RFC 2822, e omitido aqui.
Mais informações: http://www.regular-expressions.info/email.html
Não deve usar expressões regulares para validar um texto de entrada para verificar se é um e-mail. É muito complicado e não cobre todos os casos.
Como só pode cobrir 90% dos casos, escreva algo do género:function isPossiblyValidEmail(txt) {
return txt.length > 5 && txt.indexOf('@')>0;
}
Podes refiná-lo. Por exemplo, 'AAA@' é válido. Mas no geral você entende a essência. E não te entusiasmes... Uma solução simples de 90% é melhor do que uma solução de 100% que não funciona.
O mundo precisa de um código mais simples...
Basta verificar se o endereço de E-mail indicado é válido ou não usando HTML.
<input type="email"/>
Não há necessidade de escrever uma função para validação.
É assim que o validador do nó faz:
/^(?:[\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])\]))$/
Em vez de Novo RegExp
, Tente escrever o regexp
assim:
if (reg.test(/@/))
Em segundo lugar, verifique se um período vem após o sinal @
, e certifique-se de que existem caracteres entre o @
s e períodos.
Uma solução que não verifique a existência do TLD está incompleta.
Quase todas as respostas a estas perguntas sugerem o uso de Regex para validar endereços de E-mail. Acho que a Regex só serve para uma validação rudimentar. Parece que a validação de endereços de E-mail é na verdade dois problemas separados:1- validação do formato de E-mail: certificando-se se o e-mail está em conformidade com o formato e padrão dos E-mails 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 {[[0]} passe a expressão regular, não é um e-mail válido, porque ccc
não é um domínio de topo pela IANA.
2- certificando-se de que o e-mail existe realmente: para fazer isto, a única opção é para enviar um e-mail aos utilizadores.
/^([\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 10.
Mas, claro, isso é ignorar a internacionalização.Em contraste com squirtle , Aqui está uma solução complexa, mas faz um trabalho muito bom de validar 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);
}
Usar assim:
if (isEmail('[email protected]')){ console.log('This is email is valid'); }
Utilize este código dentro da sua função de Validação:
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, pode utilizar jQuery . As regras internas definem:
eMailId: {
required: true,
email: true
}
O melhor regex de sempre, o que confirma com a 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])+
Actualização Regex 2018! tenta isto.
let val = '[email protected]';
if(/^[a-z0-9][a-z0-9-_\.]+@([a-z]|[a-z0-9]?[a-z0-9-]+[a-z0-9])\.[a-z0-9]{2,10}(?:\.[a-z]{2,10})?$/.test(val)) {
console.log('passed');
}
Typscript version complete
//
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
Aqui está uma discussão muito boa sobre a utilização de expressões regulares para validar endereços de E-mail; "comparar o endereço de E-mail a validar Expressões Regulares"
Aqui está a expressão de topo actual, que é 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
O meu conhecimento de Expressões Regulares não é assim tão bom. É por isso que eu verifico a sintaxe geral com uma expressão regular simples primeiro e verifico opções mais específicas com outras funções depois. Esta pode não ser a melhor solução técnica, mas desta forma eu sou muito mais flexível e mais rápido.
Os erros mais comuns que encontrei são espaços (especialmente no início 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('[email protected]'); // Returns false
check_email(' [email protected]'); // Returns false
check_email('[email protected]'); // 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>
Sintaxe de correio normal do 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('[email protected]') // Return true
validMail('[email protected].') // Return true
validMail('[email protected]') // Return true
validMail('user@localserver') // Return true
validMail('[email protected]') // Return true
validMail('user+mailbox/[email protected]') // Return true
validMail('"very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"@strange.example.com') // Return true
validMail('!#$%&\'*+-/=?^_`.{|}[email protected]') // 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@[email protected]') // Return false
validMail('a"b(c)d,e:f;g<h>i[j\k][email protected]') // Return false
validMail('just"not"[email protected]') // Return false
validMail('this is"not\[email protected]') // Return false
validMail('this\ still\"not\\[email protected]') // Return false
validMail('[email protected]') // Return false
validMail('[email protected]') // Return false
Mostrar este teste : https://regex101.com/r/LHJ9gU/1
A expressão regular fornecida pela Microsoft dentro de ASP.NET MVC is
/^[\w-]+(\.[\w-]+)*@([a-z0-9-]+(\.[a-z0-9-]+)*?\.[a-z]{2,6}|(\d{1,3}\.){3}\d{1,3})(:\d{4})?$/
Que eu postei aqui, no caso de ser imperfeito, embora tenha sido sempre perfeito para as minhas necessidades.