Frage Wie validiere ich eine Email Adresse in JavaScript?


Wie kann eine E-Mail-Adresse in JavaScript validiert werden?


3244


Ursprung


Antworten:


Verwenden Reguläre Ausdrücke ist wahrscheinlich der beste Weg. Sie können eine Reihe von Tests sehen Hier (genommen von Chrom)

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

Hier ist das Beispiel eines regulären Ausdrucks, der Unicode akzeptiert:

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

Aber bedenken Sie, dass man sich nicht nur auf die Validierung von JavaScript verlassen sollte. JavaScript kann einfach deaktiviert werden. Dies sollte auch serverseitig validiert werden.

Hier ist ein Beispiel für das oben genannte in Aktion:

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



Nur der Vollständigkeit halber, Hier haben Sie einen anderen RFC 2822-konformen Regex

Der offizielle Standard ist bekannt als RFC 2822. Es beschreibt die Syntax, die gültige E-Mail-Adressen einhalten müssen. Sie können (aber du solltest nicht - weiter lesen) Implementiere es mit diesem regulären Ausdruck:

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

(...) Wir erhalten eine praktischere Implementierung von RFC 2822, wenn wir die Syntax mit doppelten Anführungszeichen und eckigen Klammern weglassen. Es wird immer noch 99,99% aller heute verwendeten E-Mail-Adressen entsprechen.

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

Eine weitere Änderung, die Sie vornehmen können, besteht darin, eine zweistellige Ländercode-Top-Level-Domain und nur bestimmte generische Top-Level-Domains zuzulassen. Dieser Regex filtert Dummy-E-Mail-Adressen wie asdf@adsf.adsf. Sie muss aktualisiert werden, wenn neue Top-Level-Domains hinzugefügt werden.

[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

Selbst wenn man offiziellen Standards folgt, müssen Kompromisse gemacht werden. Kopieren Sie keine regulären Ausdrücke aus Online-Bibliotheken oder Diskussionsforen. Testen Sie sie immer auf Ihren eigenen Daten und mit Ihren eigenen Anwendungen.

Schwerpunkt meiner


609



Ich habe die Antwort von Jaymon für Leute, die eine wirklich einfache Validierung wünschen, etwas modifiziert:

anystring@anystring.anystring

Der reguläre Ausdruck:

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

Beispiel JavaScript-Funktion:

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

548



Es gibt etwas, das Sie verstehen müssen, wenn Sie sich entscheiden, einen regulären Ausdruck zu verwenden, um E-Mails zu validieren: Es ist wahrscheinlich keine gute Idee. Sobald Sie sich damit abgefunden haben, gibt es viele Implementierungen, die Sie auf halbem Weg dorthin bringen können. Dieser Artikel fasst sie gut zusammen.

Kurz gesagt, der einzige Weg, absolut sicher zu sein, dass das, was der Benutzer eingegeben hat, tatsächlich eine E-Mail ist, ist tatsächlich eine E-Mail zu senden und zu sehen, was passiert. Ansonsten ist alles nur Vermutungen.


292



Wow, hier ist viel Komplexität. Wenn Sie nur die offensichtlichsten Syntaxfehler abfangen möchten, würde ich Folgendes tun:

\S+@\S+

Es fängt normalerweise die offensichtlichsten Fehler auf, die der Benutzer macht, und stellt sicher, dass das Formular größtenteils richtig ist, worum es bei der JavaScript-Validierung geht.


280



HTML5 selbst hat eine E-Mail-Validierung. Wenn Ihr Browser HTML5 unterstützt, können Sie den folgenden Code verwenden.

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

jsFiddle Verknüpfung

Von dem HTML5-Spezifikation:

EIN gültige Email Addresse ist eine Zeichenfolge, die der übereinstimmt emailProduktion des folgenden ABNF, dessen Zeichensatz Unicode ist.

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 >

Diese Anforderung ist a vorsätzliche Verletzung von RFC 5322, die eine Syntax für E-Mail-Adressen definiert, die gleichzeitig zu strikt (vor dem Zeichen "@"), zu vage (nach dem Zeichen "@") und zu locker ist (Kommentare, Leerzeichen und Anführungszeichen zulässig) Saiten in Manieren, die den meisten Benutzern unbekannt sind), um hier von praktischem Nutzen zu sein.

Der folgende JavaScript- und Perl-kompatible reguläre Ausdruck ist eine Implementierung der obigen Definition.

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



Ich habe festgestellt, dass dies die beste Lösung ist:

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

Es erlaubt die folgenden Formate:

1. prettyandsimple@beispiel.com
2. sehr.common@beispiel.de
3. disposable.style.email.with+symbol@example.com
4. Sonstiges.email-mit-dash@beispiel.com
9. #!$%&'*+-/=^^ ``{}|~@example.org
6. "() []:,; @ \\\"! # $% & '* + - / =? ^ _ `{} | ~ .a "@beispiel.org
7. "" @ example.org (Leerzeichen zwischen den Anführungszeichen)
8. üñîçøðé@example.com (Unicode-Zeichen im lokalen Teil)
9. üñîçøðé@üñîçøðé.com (Unicode-Zeichen im Domain-Teil)
10. Pelé@example.com (Latein)
11. δοκιμή@παράδειγμα.δοκιμή (Griechisch)
12. 我 買 @ 屋企. 香港 (Chinesisch)
13. 甲 斐 @ 黒 川. 日本 (Japanisch)
14. чебурашка@ящик-с-апельсинами.рф (kyrillisch)

Es ist eindeutig vielseitig und erlaubt die wichtigen internationalen Charaktere, während es immer noch das grundlegende anything@anything.anything Format durchsetzt. Es wird Räume blockieren, die technisch von RFC erlaubt sind, aber sie sind so selten, dass ich das gerne mache.


95



In modernen Browsern können Sie auf die Antwort von Sushil mit reinem JavaScript und der 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);
}

Ich habe ein Beispiel in der Geige zusammengestellt http://jsfiddle.net/boldewyn/2b6d5/. Kombiniert mit Feature-Erkennung und der Barebone-Validierung von Squirtles AntwortEs befreit dich vom regulären Ausdruck Massaker und borkt sich nicht auf alten Browsern.


76



JavaScript kann mit einem regulären Ausdruck übereinstimmen:

emailAddress.match( / some_regex /);

Hier ist ein RFC22 regulärer Ausdruck für E-Mails:

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