Come convalidare un indirizzo email in JavaScript?

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

Domanda

Come si può convalidare un indirizzo email in JavaScript?

È stato utile?

Soluzione

Utilizzando espressioni regolari è probabilmente il modo migliore.Puoi vedere una serie di test Qui (preso da 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());
}

Ecco l'esempio di espressione regolare che accetta unicode:

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

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

Ecco un esempio di quanto sopra in azione:

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>

Altri suggerimenti

Giusto per completezza, qui hai un'altra regex compatibile con RFC 2822

Lo standard ufficiale è noto come RFC2822.Descrive la sintassi a cui devono aderire gli indirizzi email validi.Puoi (ma non dovresti — continuare a leggere) implementatelo 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 della RFC 2822 se omettiamo la sintassi utilizzando virgolette doppie e parentesi quadre. Corrisponderà comunque al 99,99% di tutti gli indirizzi email 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 potresti apportare è consentire qualsiasi dominio di primo livello con codice paese a due lettere e solo domini di primo livello generici specifici. Questa regex filtra indirizzi email fittizi come asdf@adsf.adsf.Voi dovrà aggiornarlo man mano che vengono aggiunti nuovi domini di primo livello.

[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

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

Sottolineo il mio

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

qualsiasistringa@qualsiasistringa.qualsiasistringa

L'espressione regolare:

/\S+@\S+\.\S+/

Esempio di funzione JavaScript:

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

Wow, ci sono molte complessità qui.Se tutto quello che vuoi fare è solo individuare gli errori di sintassi più evidenti, farei qualcosa del genere:

^\S+@\S+$

Di solito rileva gli errori più evidenti commessi dall'utente e garantisce che il modulo sia per lo più corretto, che è lo scopo della convalida JavaScript.

C'è qualcosa che devi capire nel momento in cui decidi di utilizzare un'espressione regolare per convalidare le email: Probabilmente non è una buona idea.Una volta che hai fatto i conti con questo, ci sono molte implementazioni là fuori che possono portarti a metà strada, questo articolo li riassume bene.

In breve, però, l'unico modo per essere assolutamente sicuri che ciò che l'utente ha inserito sia effettivamente un'e-mail è inviare effettivamente un'e-mail e vedere cosa succede.Per il resto sono solo supposizioni.

Lo stesso HTML5 ha la convalida della posta elettronica.Se il tuo browser supporta HTML5 puoi utilizzare il seguente codice.

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

jsFiddle collegamento

Dal Specifiche HTML5:

UN Indirizzo e-mail valido è una stringa che corrisponde a email produzione del seguente ABNF, il cui set di caratteri è 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 è a violazione intenzionale della RFC 5322, che definisce una sintassi per gli indirizzi di posta elettronica che è allo stesso tempo troppo rigida (prima del carattere "@"), troppo vaga (dopo il carattere "@") e troppo permissiva (consentendo commenti, caratteri di spazi bianchi e virgolette stringhe in modi non familiari alla maggior parte degli utenti) per essere di uso pratico qui.

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

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

Ho trovato questa la soluzione migliore:

/^[^\s@]+@[^\s@]+\.[^\s@]+$/

Permette i seguenti formati:

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)

È chiaramente versatile e consente i più importanti caratteri internazionali, pur applicando il formato base qualsiasi@qualsiasi cosa.qualsiasi cosa.Bloccherà gli spazi tecnicamente consentiti dalla RFC, ma sono così rari che sono felice di farlo.

Nei browser moderni puoi basarti sulla risposta di @ Sushil con JavaScript puro e il file 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);
}

Ho messo insieme un esempio nel violino http://jsfiddle.net/boldewyn/2b6d5/.Combinato con il rilevamento delle funzionalità e la convalida semplice di La risposta di Squirtle, ti libera dal massacro delle espressioni regolari e non infastidisce i vecchi browser.

JavaScript può corrispondere a un'espressione regolare:

emailAddress.match( / some_regex /);

Ecco un RFC22 espressione regolare per le email:

^((?>[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)>)$

Questa è la versione RFC822 corretta.

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

Tutti gli indirizzi email contengono una "at" (ad es.@) simbolo.Verifica la condizione necessaria:

email.indexOf("@") > 0

Non preoccuparti di nulla di più complicato.Anche se potessi determinare perfettamente se un'e-mail è sintatticamente valida 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.

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

Una buona pratica è convalidare i dati sul client, ma ricontrollare la convalida sul server.Tenendo presente questo, puoi semplicemente verificare se una stringa assomiglia a 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 a 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:Scorso @ dovrebbe essere penultimo . Da @ non può far parte del nome del server (per quanto ne so).

  • lastAtPos > 0:Dovrebbe esserci qualcosa (il nome utente e-mail) prima dell'ultimo @.

  • str.indexOf('@@') == -1:Non dovrebbe esserci @@ nell'indirizzo.Anche se @ appare come ultimo carattere nel nome utente dell'e-mail, deve essere racchiuso tra virgolette " sarebbe tra quello @ e l'ultimo @ nell'indirizzo.

  • lastDotPos > 2:Ad esempio, dovrebbero esserci almeno tre caratteri prima dell'ultimo punto a@b.com.

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

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

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

  • Originale
    /^(([^<>()\[\]\\.,;:\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,}))$/

  • Modificata
    /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()\.,;\s@\"]+\.{0,1})+[^<>()\.,;:\s@\"]{2,})$/

per passare gli esempi Indirizzo e-mail di Wikipedia.

E puoi vedere il risultato in Qui.

enter image description here

Fai questo:

[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])?

Perché? È basato su RFC2822, che è uno standard a cui TUTTI gli indirizzi email DEVONO attenersi.E non sono sicuro del motivo per cui dovresti preoccuparti di qualcosa di "più semplice"...lo copierai e incollerai comunque ;)

Spesso quando memorizzo gli indirizzi email nel database li scrivo in minuscolo e, in pratica, le espressioni regolari possono solitamente essere contrassegnate senza distinzione tra maiuscole e minuscole.In questi casi questo è leggermente più breve:

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

Ecco un esempio del suo utilizzo in JavaScript (con il flag senza distinzione tra maiuscole e minuscole i alla fine).

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

Nota:
Tecnicamente alcune email possono includere virgolette nella sezione precedente al @ simbolo con caratteri di escape tra virgolette (in modo che il tuo utente di posta elettronica possa essere odioso e contenere cose come @ E "..." purché scritto tra virgolette).NESSUNO LO FA MAI!È obsoleto.Ma è incluso nel vero RFC2822 standard e qui omesso.

Ulteriori informazioni: http://www.regular-expressions.info/email.html

Non dovresti utilizzare le 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, poiché puoi coprire solo il 90% dei casi, scrivi qualcosa del tipo:

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

Puoi perfezionarlo.Ad esempio, "aaa@" è valido.Ma nel complesso hai capito il concetto.E non lasciarti trasportare...Una semplice soluzione al 90% è migliore di una soluzione al 100% che non funziona.

Il mondo ha bisogno di codici più semplici...

Controlla semplicemente se l'indirizzo email inserito è valido o non utilizza HTML.

<input type="email"/>

Non è necessario scrivere una funzione per la convalida.

Questo è come validatore del nodo lo fa:

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

È difficile ottenere un validatore di posta elettronica corretto al 100%.L'unico vero modo per farlo correttamente sarebbe inviare un'e-mail di prova all'account.Detto questo, ci sono alcuni controlli di base che possono aiutarti ad assicurarti di ottenere qualcosa di ragionevole.

Alcune cose da migliorare:

Invece di nuovo RegExp, prova a scrivere il file regexp fuori in questo modo:

if (reg.test(/@/))

In secondo luogo, controlla per assicurarti che un punto venga dopo il @ firmare e assicurarsi che ci siano caratteri tra i file @se periodi.

Utilizza questo codice all'interno della funzione di validazione:

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
}

Aggiornamento Regex 2018!prova questo

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

versione dattiloscritta completata

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

Ulteriori informazioni https://git.io/vhEfc

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

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

Quasi tutte le risposte a queste domande suggeriscono di utilizzare Regex per convalidare gli indirizzi e-mail.Penso che Regex sia utile solo per una convalida rudimentale.Sembra che il controllo della convalida degli indirizzi email sia in realtà due problemi separati:

1- Convalida del formato email: Assicurarsi che l'e-mail sia conforme al formato e al modello delle e-mail nella RFC 5322 e se il TLD esiste effettivamente.È possibile trovare un elenco di tutti i TLD validi Qui.

Ad esempio, sebbene l'indirizzo example@example.ccc passerà la regex, non è un'e-mail valida, perché ccc non è un dominio di primo livello di IANA.

2- Assicurarsi che l'e-mail esista effettivamente: Per fare questo, l'unica opzione È per inviare un'e-mail agli utenti.

A quanto pare è proprio così:

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

Preso da http://fightingforalostcause.net/misc/2006/compare-email-regex.php il 1 ottobre '10.

Ma, ovviamente, questo significa ignorare l’internazionalizzazione.

In contrasto con schizzi, ecco una soluzione complessa, ma fa un ottimo lavoro nel convalidare correttamente le email:

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('youremail@yourdomain.com')){ console.log('This is email is valid'); }

Ecco un'ottima discussione sull'uso delle espressioni regolari per convalidare gli indirizzi email;"Confronto degli indirizzi di posta elettronica per la convalida delle espressioni regolari"

Ecco l'espressione top corrente, compatibile con JavaScript, a scopo 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

La mia conoscenza di espressioni regolari non è così buono.Ecco perché controllo prima la sintassi generale con una semplice espressione regolare e successivamente controllo le opzioni più specifiche con altre funzioni.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 gli spazi (soprattutto all'inizio e alla fine) e occasionalmente un doppio punto.

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>

L'espressione regolare fornita da Microsoft all'interno 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 fosse difettoso, anche se è sempre stato perfetto per le mie esigenze.

Sintassi di 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 /^(([^<>()\[\]\.,;:\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

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

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top