Come convalidare un indirizzo e-mail in JavaScript

Esiste un'espressione regolare per convalidare un indirizzo e-mail in JavaScript?

L'uso delle espressioni regolari è probabilmente il modo migliore. Puoi vedere un sacco di test qui (presi dal cromo )

function validateEmail(email) {
    const 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 dell'espressione regolare che accetta unicode:

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

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

Ecco un esempio di quanto sopra in azione:

function validateEmail(email) {
  const 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() {
  const $result = $("#result");
  const 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>

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

anystring@anystring.anystring

L'espressione regolare:

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

Esempio di funzione JavaScript:

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

Solo per completezza, qui hai un'altra regex conforme a RFC 2822

Lo standard ufficiale è noto come RFC 2822 . Descrive la sintassi a cui devono aderire indirizzi e-mail 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 virgolette doppie e parentesi quadre. Corrisponderà ancora 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 potresti apportare è consentire qualsiasi dominio di primo livello con codice paese di due lettere e solo domini di primo livello generici specifici. Questo regex filtra indirizzi e-mail fittizi comeasdf@adsf.adsf . Dovrai 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 alla cieca espressioni regolari da biblioteche online o forum di discussione. Testali sempre sui tuoi dati e con le tue applicazioni.

_{Enfasi mia}

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

^\S+@\S+$

Di solito rileva gli errori più evidenti che l'utente commette e garantisce che il modulo sia per lo più corretto, che è la convalida JavaScript.

C'è qualcosa che devi capire nel momento in cui decidi di utilizzare un'espressione regolare per convalidare le e-mail: 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, tuttavia, l'unico modo per essere assolutamente, positivamente sicuri che ciò che l'utente ha inserito è in realtà un'e-mail è effettivamente inviare un'e-mail e vedere cosa succede. A parte questo, è solo una supposizione.

HTML5 stesso ha la convalida dell'email. Se il tuo browser supporta HTML5, puoi utilizzare il seguente codice.

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

jsFiddleCollegamento

Dalle specifiche HTML5 :

Un indirizzo e-mail valido è una stringa che corrisponde alla emailproduzione 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 di posta elettronica che è contemporaneamente troppo rigida (prima del carattere "@"), troppo vaga (dopo il carattere "@") e troppo lassista (che consente commenti , i caratteri di spazi bianchi e le stringhe citate in modi non familiari alla maggior parte degli utenti) per essere utili 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 che 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 (spazio tra le virgolette)
8. üñîçøðé@example.com (caratteri Unicode nella parte locale)
9. üñîçøðé@üñîçøðé.com (caratteri Unicode nella parte dominio)
10. Pelé@example.com (latino)
11. δοκιμή@παράδειγμα.δοκιμή (greco)
12. 我 買 @ 屋企. 香港 (cinese)
13. 甲 斐 @ 黒 川. 日本 (giapponese)
14. чебурашка@ящик-с-апельсинами.рф (cirillico)

È chiaramente versatile e consente ai personaggi internazionali di fondamentale importanza, pur applicando il formato base any@anything.anything. Bloccherà gli spazi tecnicamente consentiti da RFC, ma sono così rari che sono felice di farlo.

Nei browser moderni puoi basarti sulla risposta di @ Sushil con JavaScript puro 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() : /\S+@\S+\.\S+/.test(value);
}

Ho messo insieme un esempio nel violino http://jsfiddle.net/boldewyn/2b6d5/ . In combinazione con il rilevamento delle funzionalità e la convalida delle ossa nude dalla risposta di Squirtle , ti libera dal massacro delle espressioni regolari e non si blocca sui vecchi browser.

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

JavaScript può corrispondere a un'espressione regolare:

emailAddress.match( / some_regex /);

Ecco un'espressione regolare RFC22 per le e-mail:

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

Tutti gli indirizzi e-mail contengono un simbolo 'at' (cioè @). Prova quella condizione necessaria:

email.indexOf("@") > 0

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

La corretta convalida dell'indirizzo e-mail in conformità con le RFC non è qualcosa che può essere ottenuto con un'espressione regolare a 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. Con questo in mente, puoi semplicemente verificare se una stringa assomiglia a un indirizzo e-mail valido sul client ed eseguire il controllo rigoroso sul server.

Ecco la funzione JavaScript che uso per verificare se una stringa sembra un indirizzo di posta 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 precedente all'ultimo .poiché @non può far parte del nome del server (per quanto ne so).

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

• str.indexOf('@@') == -1: Non ci dovrebbe essere nessun @@indirizzo. Anche se @appare come l'ultimo carattere nel nome utente dell'email, deve essere citato, quindi "dovrebbe essere compreso tra quello @e l'ultimo @nell'indirizzo.

• lastDotPos > 2: Dovrebbero essere presenti almeno tre caratteri prima dell'ultimo punto, ad esempio 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 se le parentesi sono necessarie.

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

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 RFC 2822 , che è uno standard TUTTI gli indirizzi e-mail DEVONO aderire. E non sono sicuro del motivo per cui ti dovresti preoccupare di qualcosa di "più semplice" ... lo copierai e incollerai comunque;)

Spesso quando si memorizzano gli indirizzi e-mail nel database, li rendo minuscoli e, in pratica, i regex possono in genere essere contrassegnati 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 insensibile alle maiuscole ialla 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 e-mail possono includere virgolette nella sezione prima del @simbolo con caratteri di escape all'interno delle virgolette (quindi l'utente e-mail può essere odioso e contenere cose come @e "..."purché sia ​​scritto tra virgolette). NESSUNO LO FA MAI! È obsoleto Tuttavia, è incluso nel vero standard RFC 2822 e omesso qui.

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

Non vedo davvero l'ora di risolvere questo problema. Quindi ho modificato l'espressione regolare di convalida dell'email 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,}))$/

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

per passare gli esempi nell'indirizzo e -mail di Wikipedia .

E puoi vedere il risultato qui .

Non utilizzare 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. E non lasciarti trasportare ... Una soluzione semplice al 90% è migliore della soluzione al 100% che non funziona.

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

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

<input type="email"/>

Non è necessario scrivere una funzione per la convalida.

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

Alcune cose da migliorare:

Invece di nuovo RegExp, prova a scrivere regexpin questo modo:

if (reg.test(/@/))

In secondo luogo, verificare che sia presente un punto dopo il @segno e assicurarsi che vi siano caratteri tra la @s e i punti.

Ecco come fa il validatore di nodi :

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

Usa questo codice all'interno della tua 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 completa

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

maggiori informazioni https://git.io/vhEfc

Una soluzione che non verifica 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 buono solo per una validazione rudimentale. Sembra che la verifica della convalida degli indirizzi e-mail sia in realtà due problemi separati:

1- Convalida del formato e-mail: assicurarsi che l'e-mail sia conforme al formato e al modello delle e-mail in RFC 5322 e se il TLD esiste effettivamente. Un elenco di tutti i TLD validi è disponibile qui .

Ad esempio, sebbene l'indirizzo example@example.cccpassi il regex, non è un indirizzo email valido, perché cccnon è un dominio di primo livello di IANA.

2- Accertarsi che l'e-mail esista effettivamente: per fare ciò, l'unica opzione è inviare agli utenti un'e-mail .

Regex per la convalida dell'indirizzo e-mail

[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'ottima discussione sull'uso delle espressioni regolari per convalidare gli indirizzi e-mail; " Confronto dell'indirizzo e-mail che convalida le espressioni regolari "

Ecco l'espressione superiore 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

Apparentemente, tutto qui:

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

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

Ma, ovviamente, questo sta ignorando l'internazionalizzazione.

A differenza di squirtle , ecco una soluzione complessa, ma fa un ottimo lavoro nel validare 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);
} 

Usa così:

if (isEmail('youremail@yourdomain.com')){ console.log('This is email is valid'); }

La mia conoscenza delle espressioni regolari non è così buona. Ecco perché controllo prima la sintassi generale con una semplice espressione regolare e successivamente controllo 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 (specialmente 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>

Stavo cercando un Regex in JS che superi tutti i casi di test dell'indirizzo email:

• email@example.com Email valida

• firstname.lastname@example.com L'e-mail contiene un punto nel campo dell'indirizzo

• email@subdomain.example.com L'email contiene punto con sottodominio

• firstname+lastname@example.com Il segno più è considerato un carattere valido

• email@192.0.2.123 Il dominio è un indirizzo IP valido

• email@[192.0.2.123] La parentesi quadra attorno all'indirizzo IP è considerata valida

• “email”@example.com Le citazioni sull'email sono considerate valide

• 1234567890@example.com Le cifre nell'indirizzo sono valide

• email@domain-one.example Il trattino nel nome di dominio è valido

• _______@example.com Il carattere di sottolineatura nel campo dell'indirizzo è valido

• email@example.name .name è un nome di dominio di primo livello valido

• email@example.co.jpAnche il punto nel nome di dominio di primo livello è considerato valido (usando co.jpcome esempio qui)

• firstname-lastname@example.com Il trattino nel campo dell'indirizzo è valido

Eccoci qui :

http://regexr.com/3f07j

O regex:

Regex = /(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@[*[a-zA-Z0-9-]+.[a-zA-Z0-9-.]+]*/

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 inserisco qui nel caso sia difettoso, anche se è sempre stato perfetto per le mie esigenze.