regex una - Come convalidare un indirizzo email in JavaScript?



validazione form (25)

Come può un indirizzo email essere convalidato in JavaScript?


Answers

La corretta convalida dell'indirizzo email in conformità con le RFC non è qualcosa che può essere ottenuto con un'espressione regolare one-liner. Un articolo con la migliore soluzione che ho trovato in PHP è Qual è un indirizzo email valido? . Ovviamente, è stato portato su Java. Penso che la funzione sia troppo complessa per essere portata e utilizzata in JavaScript. Porta JavaScript / node.js: https://www.npmjs.com/package/email-addresses .

È buona norma convalidare i dati sul client, ma ricontrollare la convalida sul server. Con questo in mente, puoi semplicemente verificare se una stringa assomiglia ad un indirizzo email valido sul client ed eseguire il controllo rigoroso sul server.

Ecco la funzione JavaScript che utilizzo per verificare se una stringa assomiglia ad un indirizzo email valido:

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

Spiegazione:

  • lastAtPos < lastDotPos : last @ dovrebbe essere prima dell'ultimo . poiché @ non può far parte del nome del server (per quanto ne so).

  • lastAtPos > 0 : Ci dovrebbe essere qualcosa (il nome utente email) prima dell'ultimo @ .

  • str.indexOf('@@') == -1 : Non ci dovrebbero essere @@ nell'indirizzo. Anche se @ appare come l'ultimo carattere nel nome utente della email, deve essere indicato tra virgolette così " e tra l' @ e l'ultimo @ nell'indirizzo.

  • lastDotPos > 2 : dovrebbero esserci almeno tre caratteri prima dell'ultimo punto, ad esempio [email protected] .

  • (str.length - lastDotPos) > 2 : Ci dovrebbero essere abbastanza caratteri dopo l'ultimo punto per formare un dominio a due caratteri. Non sono sicuro che le parentesi siano necessarie.


Questa è la versione corretta di 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);
}

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

È sufficiente verificare se l'indirizzo email inserito è valido o non utilizza HTML.

<input type="email"/>

Non è necessario scrivere una funzione per la convalida.


La migliore regex di sempre che conferma con 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])+


Ho leggermente modificato la risposta di Jaymon per le persone che vogliono una convalida davvero semplice sotto forma di:

[email protected]

L'espressione regolare:

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

Esempio di funzione JavaScript:

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

Solo per completezza, qui avete un altro regex conforme a RFC 2822

Lo standard ufficiale è noto come RFC 2822 . Descrive la sintassi a cui devono essere conformi gli indirizzi email validi. Puoi ( ma non dovresti - continua a leggere ) implementarlo con questa espressione regolare:

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

(...) Otteniamo un'implementazione più pratica di RFC 2822 se omettiamo la sintassi usando doppie virgolette e parentesi quadre. Corrisponde comunque al 99,99% di tutti gli indirizzi e-mail attualmente in uso.

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

Un'ulteriore modifica che è possibile fare è consentire qualsiasi dominio di primo livello con codice a due lettere e solo domini generici di primo livello specifici. Questa regex filtra gli indirizzi email fittizi come [email protected] . Dovrai aggiornarlo quando verranno aggiunti nuovi domini di primo livello .

[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+(?:[AZ]{2}|com|org|net|gov|mil|biz|info|mobi|name|aero|jobs|museum)\b

Quindi anche quando si seguono gli standard ufficiali, ci sono ancora dei compromessi da fare. Non copiare ciecamente le espressioni regolari dalle biblioteche online o dai forum di discussione. Provali sempre sui tuoi dati e con le tue applicazioni.

Enfasi mia


Una soluzione che non controlla l'esistenza del TLD è incompleta.

Quasi tutte le risposte a queste domande suggeriscono di utilizzare Regex per convalidare gli indirizzi di posta elettronica. Penso che Regex sia valido solo per una validazione rudimentale. Sembra che la verifica degli indirizzi e-mail sia in realtà due problemi separati:

1- Convalida del formato e-mail: accertarsi che l'e-mail sia conforme al formato e al modello delle e-mail in RFC 5322 e che il TLD esista effettivamente. Un elenco di tutti i TLD validi può essere trovato here .

Ad esempio, sebbene l'indirizzo [email protected] supererà la regex, non è un'e-mail valida, perché ccc non è un dominio di primo livello di IANA.

2- Assicurati che l'e-mail sia effettivamente esistente: per fare ciò, l'unica opzione è quella di inviare agli utenti un'email .


Sintassi della posta standard di Wikipedia:

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

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

// VALID MAILS

validMail('[email protected]') // Return true
validMail('[email protected]') // Return true
validMail('[email protected]') // Return true
validMail('[email protected]') // Return true
validMail('[email protected]') // Return true
validMail('user+mailbox/[email protected]') // Return true
validMail('"very.(),:;<>[]\".VERY.\"[email protected]\\ \"very\".unusual"@strange.example.com') // Return true
validMail('!#$%&\'*+-/=?^_`.{|}[email protected]') // Return true
validMail('"()<>[]:,;@\\\"!#$%&\'-/=?^_`{}| ~.a"@example.org') // Return true
validMail('"[email protected]"@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('[email protected][IPv6:2001:DB8::1]') // Return true

// INVALID MAILS

validMail('Abc.example.com') // Return false
validMail('[email protected]@[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

Mostra questo test: https://regex101.com/r/LHJ9gU/1


Tutti gli indirizzi email contengono un simbolo 'at' (cioè @). Prova questa condizione necessaria:

email.indexOf("@") > 0

Non preoccuparti di nulla di più complicato. Anche se tu potessi determinare perfettamente se un'e-mail è valida sintatticamente per RFC, ciò non ti direbbe se appartiene alla persona che l'ha fornita. Questo è ciò che conta davvero.

Per verificarlo, invia un messaggio di convalida.


Questo è stato rubato da 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;}

Usa questo codice all'interno della tua funzione di validatore:

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

Altrimenti puoi usare jQuery . Le regole interne definiscono:

eMailId: {
    required: true,
    email: true
}

C'è qualcosa che devi capire nel momento in cui decidi di usare un'espressione regolare per convalidare le e-mail: probabilmente non è una buona idea . Una volta che sei venuto a patti con questo, ci sono molte implementazioni là fuori che possono farti arrivare a metà strada, questo articolo li riassume bene.

In breve, tuttavia, l'unico modo per essere assolutamente, positivamente sicuro che ciò che l'utente ha inserito è in realtà una e-mail è effettivamente inviare una e-mail e vedere cosa succede. Oltre a questo è tutto solo supposizioni.


Non dovresti usare espressioni regolari per convalidare una stringa di input per verificare se si tratta di un'e-mail. È troppo complicato e non coprirebbe tutti i casi.

Ora dal momento che puoi coprire solo il 90% dei casi, scrivi qualcosa come:

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

Puoi perfezionarlo. Ad esempio, 'aaa @' è valido. Ma nel complesso ottieni il succo. E non lasciarti trasportare ... Una soluzione semplice al 90% è meglio della soluzione al 100% che non funziona.

Il mondo ha bisogno di un codice più semplice ...


È difficile ottenere un validatore di e-mail corretto al 100%. L'unico vero modo per farlo correttamente sarebbe inviare una e-mail di prova all'account. Detto questo, ci sono alcuni controlli di base che possono aiutare a essere sicuri di ottenere qualcosa di ragionevole.

Alcune cose da migliorare:

Invece del nuovo RegExp , prova a scrivere la regexp in questo modo:

if (reg.test(/@/))

In secondo luogo, verifica che venga raggiunto un punto dopo il segno @ e assicurati che vi siano dei caratteri tra le @ e i periodi.


Nei browser moderni puoi costruire la risposta di @Sushil con puro JavaScript e il 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() : /\[email protected]\S+\.\S+/.test(value);
}

Ho messo insieme un esempio nel fiddle http://jsfiddle.net/boldewyn/2b6d5/ . Combinato con il rilevamento di feature e la validazione bare-bones di Squirtle's Answer , ti libera dal massacro delle espressioni regolari e non si collega ai vecchi browser.


L'espressione regolare fornita da Microsoft all'interno di ASP.NET MVC è

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

Che pubblico qui nel caso in cui sia difettoso, anche se è sempre stato perfetto per le mie esigenze.



Usare le espressioni regolari è probabilmente il modo migliore. Puoi vedere un sacco di test here (presi da 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());
}

Ecco l'esempio di un'espressione regolare che accetta unicode:

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

Ma tieni presente che non si deve fare affidamento solo sulla convalida JavaScript. JavaScript può essere facilmente disabilitato. Questo dovrebbe essere convalidato anche dal lato server.

Ecco un esempio di quanto sopra in azione:

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>


Ecco una discussione molto buona sull'uso di espressioni regolari per convalidare gli indirizzi email; " http://fightingforalostcause.net/misc/2006/compare-email-regex.php "

Ecco l'espressione principale corrente, che è compatibile con JavaScript, a fini di riferimento:

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

Ho trovato che questa fosse la soluzione migliore:

/^[^\[email protected]][email protected][^\[email protected]]+\.[^\[email protected]]+$/

Permette i seguenti formati:

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)

È chiaramente versatile e consente i più importanti personaggi internazionali, mentre continua a imporre l'essenziale qualsiasi cosa.questo formato. Bloccherà gli spazi tecnicamente autorizzati da RFC, ma sono così rari che sono felice di farlo.


La mia conoscenza delle espressioni regolari non è buona. Ecco perché prima controllo la sintassi generale con una semplice espressione regolare e controllo più opzioni specifiche con altre funzioni in seguito. Questa potrebbe non essere la migliore soluzione tecnica, ma in questo modo sono molto più flessibile e veloce.

Gli errori più comuni che ho riscontrato sono spazi (specialmente all'inizio e alla fine) e occasionalmente un doppio punto.

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

Al contrario di Squirtle , ecco una soluzione complessa, ma fa un ottimo lavoro per convalidare correttamente le e-mail:

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

Utilizzare in questo modo:

if (isEmail('[email protected]')){ console.log('This is email is valid'); }

Wow, ci sono molte complessità qui. Se tutto quello che vuoi fare è catturare gli errori di sintassi più ovvi, vorrei fare qualcosa del genere:

\[email protected]\S+

Solitamente rileva gli errori più ovvi che l'utente fa e assicura che il modulo sia per lo più corretto, che è ciò che è la validazione JavaScript.


Ci sono tre implementazioni di foreachin jQuery come segue.

var a = [3,2];

$(a).each(function(){console.log(this.valueOf())}); //Method 1
$.each(a, function(){console.log(this.valueOf())}); //Method 2
$.each($(a), function(){console.log(this.valueOf())}); //Method 3




javascript regex validation email email-validation