regular - validar telefone javascript




Como validar um endereço de email em JavaScript? (20)

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

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

1- Validação do formato de e-mail: Certificando-se de que o e-mail está em conformidade com o formato e padrão de e-mails no RFC 5322 e se o TLD realmente existe. Uma lista de todos os TLDs válidos pode ser encontrada here .

Por exemplo, embora o endereço [email protected]passe a 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 e-mail realmente existe: Para fazer isso, a única opção é enviar um e-mail aos usuários .

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


A validação correta 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. Um artigo com a melhor solução que encontrei no PHP é o que é um endereço de email válido? . Obviamente, ele foi portado para o 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 a verificação estrita no servidor.

Aqui está a função JavaScript que eu 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 : Último @ deve ser anterior ao último . já que @ 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 @@ no endereço. Mesmo que @ apareça como o último caractere no nome de usuário do e-mail, ele deve ser citado de forma que " 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 certeza se os colchetes são necessários.


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

Estou realmente ansioso para resolver esse problema. Então, modifiquei a expressão regular de validação de e-mail acima

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

E você pode ver o resultado here .


Eu modifiquei ligeiramente a resposta de Jaymon para pessoas que querem validação realmente simples na forma de:

[email protected]

A expressão regular:

/\[email protected]\S+\.\S+/

Exemplo de função JavaScript:

function validateEmail(email) 
{
    var re = /\[email protected]\S+\.\S+/;
    return re.test(email);
}

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 no RFC 2822 , que é um padrão que todos os endereços de e-mail devem seguir.

Muitas vezes, ao armazenar endereços de e-mail no banco de dados, eu os deixo em minúsculas e, na prática, os regexs geralmente podem ser marcados sem distinção entre maiúsculas e minúsculas. Nesses casos, isso é um pouco menor:

[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 que está sendo usado em JavaScript (com o flag insensitivo de maiúsculas e minúsculas 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('[email protected]') );

Nota :
Tecnicamente, alguns e-mails podem incluir citações na seção antes do símbolo @ com caracteres de escape dentro das aspas (então seu usuário de e-mail pode ser ofensivo e conter coisas como @ e "..." desde que estejam escritas entre aspas). NINGUÉM FAZ ISSO NUNCA! Está obsoleto. Mas, ele está incluído no verdadeiro padrão RFC 2822 e omitido aqui.

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


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

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

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

<form><input type="email" placeholder="[email protected]">
    <input type="submit">
</form>

jsFiddle link

Da especificação do HTML5 :

Um endereço de email válido é uma cadeia de caracteres que corresponde à produção de email 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 >

Esse requisito é uma violação intencional do RFC 5322, que define uma sintaxe para endereços de email que é simultaneamente muito rígida (antes do caractere "@"), muito vaga (após o caractere "@") e muito flexível (permitindo comentários) , caracteres em branco, e strings citadas em maneiras desconhecidas para a maioria dos usuários) 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.!#$%&'*+/=?^_`{|}~-][email protected][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])?)*$/

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

email.indexOf("@") > 0

Não se incomode com nada mais complicado. Mesmo se você pudesse determinar perfeitamente se um email é 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.


Usar expressões regulares é provavelmente o melhor caminho. Você pode ver um monte de testes here (tirados do chromium )

function validateEmail(email) {
    var re = /^(([^<>()\[\]\\.,;:\[email protected]"]+(\.[^<>()\[\]\\.,;:\[email protected]"]+)*)|(".+"))@((\[[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 da expressão regular que aceita unicode:

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

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

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

function validateEmail(email) {
  var re = /^(([^<>()[\]\\.,;:\[email protected]\"]+(\.[^<>()[\]\\.,;:\[email protected]\"]+)*)|(\".+\"))@((\[[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>


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ê pode cobrir apenas 90% dos casos, escreva algo como:

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

Você pode refinar isso. Por exemplo, 'aaa @' é válido. Mas no geral você ganha a essência. E não se deixe levar ... Uma solução simples de 90% é melhor que a 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.


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

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

Senão você pode usar o jQuery . Regras internas definem:

eMailId: {
    required: true,
    email: true
}

É assim que o node-validator faz isso:

/^(?:[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+\.)*[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~][email protected](?:(?:(?:[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])\]))$/

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 postei aqui caso seja falho - embora sempre tenha sido perfeito para as minhas necessidades.


Aqui está uma boa discussão sobre como usar expressões regulares para validar endereços de e-mail; " http://fightingforalostcause.net/misc/2006/compare-email-regex.php "

Aqui está a expressão top atual, 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

Em contraste com o squirtle , aqui está uma solução complexa, mas 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('[email protected]')){ console.log('This is email is valid'); }

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

Os erros mais comuns que eu encontrei são espaços (especialmente no início e no final) e, ocasionalmente, um ponto duplo.

function check_email(val){
    if(!val.match(/\[email protected]\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('[email protected]'); // Returns false
check_email('[email protected]'); // Returns false
check_email(' [email protected]'); // Returns false
check_email('[email protected]'); // Returns true




email-validation