verifica Come convalidare un indirizzo email in JavaScript?




validazione indirizzo email (20)

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 .

https://code.i-harness.com

Come può un indirizzo email essere convalidato in JavaScript?


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



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.


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

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


Lo stesso HTML5 ha la convalida e-mail. Se il tuo browser supporta HTML5, puoi utilizzare il seguente codice.

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

collegamento jsFiddle

Dalle specifiche HTML5 :

Un indirizzo e-mail valido è una stringa che corrisponde alla produzione di e-mail del seguente ABNF, il set di caratteri per il quale è 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 >

Questo requisito è una violazione intenzionale di RFC 5322, che definisce una sintassi per gli indirizzi e-mail che è simultaneamente troppo severa (prima del carattere "@"), troppo vaga (dopo il carattere "@"), e troppo lassa (che consente commenti , caratteri di spazi vuoti e stringhe citate in modi non familiari alla maggior parte degli utenti) per essere utili in questo caso.

La seguente espressione regolare compatibile con JavaScript e Perl è un'implementazione della suddetta definizione.

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

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


Non vedo davvero l'ora di risolvere questo problema. Così ho modificato l'espressione regolare di convalida della posta elettronica sopra

per passare gli esempi nell'indirizzo email di Wikipedia .

E puoi vedere il risultato here .


Questo è come fa il node-validator :

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

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

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.


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>


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


Aggiornamento Regex 2018! prova questo

let val = '[email protected]';
if(/^[a-z0-9][a-z0-9-_\.][email protected]([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');
}

versione dattiloscritta completa

//
export const emailValid = (val:string):boolean => /^[a-z0-9][a-z0-9-_\.][email protected]([a-z]|[a-z0-9]?[a-z0-9-]+[a-z0-9])\.[a-z0-9]{2,10}(?:\.[a-z]{2,10})?$/.test(val);

maggiori informazioni https://git.io/vhEfc


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
}

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

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.


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




email-validation