So überprüfen Sie eine E-Mail-Adresse in JavaScript

Gibt es einen regulären Ausdruck zum Überprüfen einer E-Mail-Adresse in JavaScript?

Die Verwendung regulärer Ausdrücke ist wahrscheinlich der beste Weg. Sie können hier eine Reihe von Tests sehen (aus Chrom )

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

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

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

Beachten Sie jedoch, dass Sie sich nicht nur auf die JavaScript-Validierung verlassen sollten. JavaScript kann einfach deaktiviert werden. Dies sollte auch auf der Serverseite überprüft werden.

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

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>

Ich habe Jaymons Antwort für Leute, die eine wirklich einfache Validierung wünschen, leicht modifiziert in Form von:

anystring@anystring.anystring

Der reguläre Ausdruck:

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

Beispiel für eine JavaScript-Funktion:

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

Der Vollständigkeit halber haben Sie hier einen weiteren RFC 2822-kompatiblen regulären Ausdruck

Der offizielle Standard ist als RFC 2822 bekannt . Es beschreibt die Syntax, die gültige E-Mail-Adressen einhalten müssen. Sie können ( aber Sie sollten nicht - lesen Sie weiter ) implementieren 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 in doppelten Anführungszeichen und eckigen Klammern weglassen. Es entspricht immer noch 99,99% aller E-Mail-Adressen, die heute tatsächlich verwendet werden.

[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 aus zwei Buchstaben bestehende Ländercode-Top-Level-Domain und nur bestimmte generische Top-Level-Domains zuzulassen. Diese Regex filtert Dummy-E-Mail-Adressen wieasdf@adsf.adsf . Sie müssen es aktualisieren, 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 offizielle Standards eingehalten werden, müssen noch Kompromisse geschlossen werden. Kopieren Sie reguläre Ausdrücke nicht blind aus Online-Bibliotheken oder Diskussionsforen. Testen Sie sie immer an Ihren eigenen Daten und mit Ihren eigenen Anwendungen.

_{Hervorhebung von mir}

Wow, hier gibt es 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 ab, die der Benutzer macht, und stellt sicher, dass das Formular größtenteils richtig ist, worum es bei der JavaScript-Validierung geht.

Es gibt etwas, das Sie verstehen müssen, sobald Sie sich entscheiden, einen regulären Ausdruck zum Validieren von E-Mails zu verwenden: 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, die einzige Möglichkeit, absolut sicher zu sein, dass der Benutzer tatsächlich eine E-Mail eingegeben hat, besteht darin, tatsächlich eine E-Mail zu senden und zu sehen, was passiert. Davon abgesehen ist alles nur eine Vermutung.

HTML5 selbst verfügt über 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" required>
    <input type="submit">
</form>

jsFiddle Link

Aus der HTML5-Spezifikation :

Eine gültige E-Mail-Adresse ist eine Zeichenfolge, die der emailProduktion des folgenden ABNF entspricht, 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 stellt eine vorsätzliche Verletzung von RFC 5322 dar, das eine Syntax für E-Mail-Adressen definiert, die gleichzeitig zu streng (vor dem Zeichen "@"), zu vage (nach dem Zeichen "@") und zu lasch (Kommentare zulassen) ist , Leerzeichen und zitierte Zeichenfolgen auf eine Weise, die den meisten Benutzern unbekannt ist), 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])?)*$/

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

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

Es erlaubt die folgenden Formate:

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 (Leerzeichen zwischen den Anführungszeichen)
8. üñîçøðé@example.com (Unicode-Zeichen im lokalen Teil)
9. üñîçøðé@üñîçøðé.com (Unicode-Zeichen im Domain-Teil)
10. Pelé@example.com (lateinisch)
11. δοκιμή@παράδειγμα.δοκιμή (Griechisch)
12. 我 買 @ 屋企. 香港 (Chinesisch)
13. Japanese 斐 @ 黒 川. 日本 (Japanisch)
14. Cyrебурашка@ящик-с-апельсинами.рф (kyrillisch)

Es ist eindeutig vielseitig und erlaubt die wichtigsten internationalen Charaktere, während das grundlegende Format "any@anything.anything" durchgesetzt wird. Es werden Leerzeichen blockiert, die von RFC technisch zugelassen sind, aber sie sind so selten, dass ich das gerne mache.

In modernen Browsern können Sie mit reinem JavaScript und dem DOM auf der Antwort von @ Sushil aufbauen :

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 http://jsfiddle.net/boldewyn/2b6d5/ zusammengestellt . In Kombination mit der Funktionserkennung und der Bare-Bones-Validierung von Squirtle's Answer befreit es Sie vom Massaker mit regulären Ausdrücken und belastet alte Browser nicht.

Dies ist die richtige RFC822-Version.

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 kann einem regulären Ausdruck entsprechen:

emailAddress.match( / some_regex /);

Hier ist ein regulärer RFC22- 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)>)$

Alle E-Mail-Adressen enthalten ein 'at'-Symbol (dh @). Testen Sie diese notwendige Bedingung:

email.indexOf("@") > 0

Kümmere dich nicht um etwas Komplizierteres. Selbst wenn Sie perfekt feststellen könnten, ob eine E-Mail RFC-syntaktisch gültig ist, würde dies Ihnen nicht sagen, ob sie der Person gehört, die sie bereitgestellt hat. Darauf kommt es wirklich an.

Um dies zu testen, senden Sie eine Validierungsnachricht.

Eine korrekte Validierung der E-Mail-Adresse in Übereinstimmung mit den RFCs kann mit einem regulären Einzeiler-Ausdruck nicht erreicht werden. Ein Artikel mit der besten Lösung, die ich in PHP gefunden habe, lautet: Was ist eine gültige E-Mail-Adresse? . Offensichtlich wurde es nach Java portiert. Ich denke, die Funktion ist zu komplex, um in JavaScript portiert und verwendet zu werden. JavaScript / node.js-Port: https://www.npmjs.com/package/email-addresses .

Es empfiehlt sich, Ihre Daten auf dem Client zu validieren, die Validierung auf dem Server jedoch noch einmal zu überprüfen. In diesem Sinne können Sie einfach überprüfen, ob eine Zeichenfolge wie eine gültige E-Mail-Adresse auf dem Client aussieht, und die strenge Überprüfung auf dem Server durchführen.

Hier ist die JavaScript-Funktion, mit der ich überprüfe, ob eine Zeichenfolge wie eine gültige E-Mail-Adresse aussieht:

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

Erläuterung:

• lastAtPos < lastDotPos: Last @sollte vor last sein, .da @es nicht Teil des Servernamens sein kann (soweit ich weiß).

• lastAtPos > 0: Vor dem letzten sollte etwas (der E-Mail-Benutzername) stehen @.

• str.indexOf('@@') == -1: @@Die Adresse sollte keine enthalten . Selbst wenn es @als letztes Zeichen im E-Mail-Benutzernamen erscheint, muss es in Anführungszeichen gesetzt werden ", also zwischen diesem @und dem letzten @in der Adresse.

• lastDotPos > 2: Es sollten zum Beispiel mindestens drei Zeichen vor dem letzten Punkt stehen a@b.com.

• (str.length - lastDotPos) > 2: Nach dem letzten Punkt sollten genügend Zeichen stehen, um eine Domäne mit zwei Zeichen zu bilden. Ich bin mir nicht sicher, ob die Klammern notwendig sind.

Dies wurde von http://codesnippets.joyent.com/posts/show/1917 gestohlen

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

Mach das:

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

Warum? Es basiert auf RFC 2822 , einem Standard, den ALLE E-Mail-Adressen einhalten MÜSSEN. Und ich bin mir nicht sicher, warum du dich mit etwas "Einfacherem" beschäftigen würdest ... du wirst es trotzdem kopieren und einfügen;)

Wenn ich E-Mail-Adressen in der Datenbank speichere, mache ich sie oft in Kleinbuchstaben und in der Praxis können reguläre Ausdrücke normalerweise ohne Berücksichtigung der Groß- und Kleinschreibung markiert werden. In diesen Fällen ist dies etwas kürzer:

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

Hier ist ein Beispiel für die Verwendung in JavaScript (mit dem Flag für Groß- und Kleinschreibung iam Ende).

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

Hinweis :
Technisch gesehen können einige E-Mails Anführungszeichen im Abschnitt vor dem @Symbol mit Escape-Zeichen in den Anführungszeichen enthalten (sodass Ihr E-Mail-Benutzer unausstehlich sein und Dinge wie @und enthalten kann, "..."solange sie in Anführungszeichen geschrieben sind). Niemand tut dies jemals! Es ist veraltet. Es ist jedoch im wahren RFC 2822- Standard enthalten und wird hier weggelassen.

Weitere Informationen: http://www.regular-expressions.info/email.html

Ich freue mich sehr darauf, dieses Problem zu lösen. Also habe ich den regulären Ausdruck für die E-Mail-Validierung oben geändert

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

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

um die Beispiele in der Wikipedia-E-Mail-Adresse zu übergeben .

Und Sie können das Ergebnis hier sehen .

Sie sollten keine regulären Ausdrücke verwenden, um eine Eingabezeichenfolge zu überprüfen und zu überprüfen, ob es sich um eine E-Mail handelt. Es ist zu kompliziert und würde nicht alle Fälle abdecken.

Da Sie jetzt nur 90% der Fälle abdecken können, schreiben Sie Folgendes:

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

Sie können es verfeinern. Zum Beispiel ist 'aaa @' gültig. Aber insgesamt bekommt man das Wesentliche. Und lassen Sie sich nicht mitreißen ... Eine einfache 90% ige Lösung ist besser als eine 100% ige Lösung, die nicht funktioniert.

Die Welt braucht einfacheren Code ...

Überprüfen Sie einfach, ob die eingegebene E-Mail-Adresse gültig ist oder nicht.

<input type="email"/>

Es ist nicht erforderlich, eine Funktion zur Validierung zu schreiben.

Es ist schwierig, einen E-Mail-Validator zu 100% korrekt zu machen. Die einzige Möglichkeit, dies zu korrigieren, besteht darin, eine Test-E-Mail an das Konto zu senden. Es gibt jedoch einige grundlegende Überprüfungen, mit denen Sie sicherstellen können, dass Sie etwas Vernünftiges erhalten.

Einige Dinge zu verbessern:

RegExpVersuchen Sie statt neu einfach, das regexpwie folgt zu schreiben :

if (reg.test(/@/))

Stellen Sie zweitens sicher, dass nach dem @Zeichen ein Punkt steht , und stellen Sie sicher, dass zwischen @s und Punkt Zeichen stehen .

So macht es der Node-Validator :

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

Verwenden Sie diesen Code in Ihrer Validierungsfunktion:

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

Andernfalls können Sie jQuery verwenden . Innerhalb Regeln definieren:

eMailId: {
    required: true,
    email: true
}

Regex Update 2018! Versuche dies

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

Typoskript-Version abgeschlossen

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

Weitere Informationen https://git.io/vhEfc

Eine Lösung, die das Vorhandensein der TLD nicht überprüft, ist unvollständig.

Fast alle Antworten auf diese Fragen schlagen vor, Regex zur Validierung von E-Mail-Adressen zu verwenden. Ich denke, Regex ist nur für eine rudimentäre Validierung gut. Es scheint, dass die Überprüfung der Validierung von E-Mail-Adressen tatsächlich zwei separate Probleme darstellt:

1- Validierung des E-Mail-Formats: Stellen Sie sicher, dass die E-Mail dem Format und Muster der E-Mails in RFC 5322 entspricht und ob die TLD tatsächlich vorhanden ist. Eine Liste aller gültigen TLDs finden Sie hier .

Obwohl die Adresse example@example.cccden regulären Ausdruck übergibt, handelt es sich beispielsweise nicht um eine gültige E-Mail, da ccces sich bei IANA nicht um eine Top-Level-Domain handelt.

2- Sicherstellen , dass die E - Mail tatsächlich existiert: dies zu tun, ist die einzige Option ist den Benutzer eine E - Mail zu senden .

Regex zur Überprüfung der E-Mail-Adresse

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

Hier ist eine sehr gute Diskussion über die Verwendung regulärer Ausdrücke zum Überprüfen von E-Mail-Adressen. " Vergleichen der E-Mail-Adresse zur Überprüfung regulärer Ausdrücke "

Hier ist der aktuelle Top-Ausdruck, der JavaScript-kompatibel ist, zu Referenzzwecken:

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

Anscheinend ist es das:

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

Entnommen aus http://fightingforalostcause.net/misc/2006/compare-email-regex.php am 1. Oktober '10.

Aber das ignoriert natürlich die Internationalisierung.

Im Gegensatz zu Squirtle gibt es hier eine komplexe Lösung, mit der E-Mails jedoch ordnungsgemäß validiert werden können:

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

Verwenden Sie wie folgt:

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

Meine Kenntnisse über reguläre Ausdrücke sind nicht so gut. Deshalb überprüfe ich zuerst die allgemeine Syntax mit einem einfachen regulären Ausdruck und überprüfe anschließend spezifischere Optionen mit anderen Funktionen. Dies ist möglicherweise nicht die beste technische Lösung, aber auf diese Weise bin ich viel flexibler und schneller.

Die häufigsten Fehler, auf die ich gestoßen bin, sind Leerzeichen (insbesondere am Anfang und am Ende) und gelegentlich ein doppelter Punkt.

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>

Ich habe nach einem Regex in JS gesucht, der alle Testfälle für E-Mail-Adressen besteht:

• email@example.com Gültige E-Mail

• firstname.lastname@example.com E-Mail enthält einen Punkt im Adressfeld

• email@subdomain.example.com E-Mail enthält Punkt mit Subdomain

• firstname+lastname@example.com Das Pluszeichen gilt als gültiges Zeichen

• email@192.0.2.123 Domain ist gültige IP-Adresse

• email@[192.0.2.123] Die eckige Klammer um die IP-Adresse gilt als gültig

• “email”@example.com Zitate rund um E-Mail gelten als gültig

• 1234567890@example.com Ziffern in der Adresse sind gültig

• email@domain-one.example Ein Strich im Domainnamen ist gültig

• _______@example.com Der Unterstrich im Adressfeld ist gültig

• email@example.name .name ist ein gültiger Top Level Domain Name

• email@example.co.jpPunkt im Top Level Domain Name wird ebenfalls als gültig angesehen (am co.jpBeispiel hier)

• firstname-lastname@example.com Der Strich im Adressfeld ist gültig

Auf geht's :

http://regexr.com/3f07j

ODER Regex:

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

Der reguläre Ausdruck, der von Microsoft in ASP.NET MVC bereitgestellt wird, lautet

/^[\w-]+(\.[\w-]+)*@([a-z0-9-]+(\.[a-z0-9-]+)*?\.[a-z]{2,6}|(\d{1,3}\.){3}\d{1,3})(:\d{4})?$/

Was ich hier poste, falls es fehlerhaft ist - obwohl es immer perfekt für meine Bedürfnisse war.