Domanda Come convalidare un indirizzo email in JavaScript?


Come può un indirizzo email essere convalidato in JavaScript?


3244


origine


risposte:


utilizzando espressioni regolari è probabilmente il modo migliore. Puoi vedere un sacco 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 un'espressione regolare che accetta unicode:

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


3779



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 - continuare a leggere) implementalo 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 asdf@adsf.adsf. tu sarà necessario aggiornarlo quando verranno 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 biblioteche online o dai forum di discussione. Provali sempre sui tuoi dati e con le tue applicazioni.

Enfasi mia


609



Ho leggermente modificato la risposta di Jaymon per le persone che vogliono 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);
}

548



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.


292



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

\S+@\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.


280



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

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

jsFiddle collegamento

Dal Specifiche HTML5:

UN Indirizzo e-mail valido è una stringa che corrisponde al 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 è a violazione intenzionale di RFC 5322, che definisce una sintassi per gli indirizzi di posta elettronica che è simultaneamente troppo severa (prima del carattere "@"), troppo vaga (dopo il carattere "@"), e troppo lassa (consentendo commenti, caratteri di spazi bianchi e quotati stringhe in maniere 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 suddetta definizione.

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

165



Ho trovato che questa fosse 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 virgolette)
8. üñîçøðé@example.com (caratteri Unicode nella parte locale)
9. üñîçøðé@üñîçøðé.com (Caratteri Unicode nella parte del dominio)
10. Pelé@example.com (latino)
11. δοκιμή@παράδειγμα.δοκιμή (greco)
12. 我 買 @ 屋企. 香港 (cinese)
13. 甲 斐 @ 黒 川. 日本 (giapponese)
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.


95



Nei browser moderni puoi costruire in cima alla 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/. Combinato con il rilevamento delle feature e la convalida delle bare bare da Risposta di Squirtle, ti libera dal massacro delle espressioni regolari e non si collega ai vecchi browser.


76



JavaScript può abbinare un'espressione regolare:

emailAddress.match( / some_regex /);

Ecco un RFC22 espressione regolare per 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)>)$

63