Wie validiere ich eine E-Mail-Adresse in JavaScript?

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

Frage

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

War es hilfreich?

Lösung

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

Bedenken Sie jedoch, dass man sich nicht nur auf die JavaScript-Validierung verlassen sollte.JavaScript kann einfach deaktiviert werden.Dies sollte auch serverseitig validiert werden.

Hier ist ein Beispiel für das oben Gesagte 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").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>

Andere Tipps

Nur der Vollständigkeit halber, Hier haben Sie einen weiteren RFC 2822-kompatiblen regulären Ausdruck

Der offizielle Standard heißt RFC 2822.Es beschreibt die Syntax, die gültige E-Mail-Adressen einhalten müssen.Du kannst (aber das solltest du nicht — weiter lesen) implementieren Sie 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 Umsetzung von RFC 2822, wenn wir die Syntax weglassen und doppelte Anführungszeichen und eckige Klammern verwenden. Es entspricht immer noch 99,99 % aller heute tatsächlich genutzten E-Mail-Adressen.

[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önnten, besteht darin, jede aus zwei Buchstaben bestehende Ländercode-Top-Level-Domain und nur bestimmte generische Top-Level-Domains zuzulassen. Dieser reguläre Ausdruck filtert Dummy-E-Mail-Adressen wie asdf@adsf.adsf.Du muss 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 immer noch Kompromisse eingegangen werden. Kopieren Sie reguläre Ausdrücke nicht blind aus Online-Bibliotheken oder Diskussionsforen.Testen Sie sie immer anhand Ihrer eigenen Daten und mit Ihren eigenen Anwendungen.

Hervorhebung von mir

Ich habe Jaymons Antwort für Leute, die eine wirklich einfache Validierung wünschen, leicht geändert in der Form:

anystring@anystring.anystring

Der reguläre Ausdruck:

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

Beispiel einer JavaScript-Funktion:

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

Wow, hier gibt es eine Menge Komplexität.Wenn Sie lediglich die offensichtlichsten Syntaxfehler erkennen möchten, würde ich Folgendes tun:

^\S+@\S+$

Es erkennt normalerweise die offensichtlichsten Fehler, die der Benutzer macht, und stellt sicher, dass das Formular größtenteils korrekt ist, und genau darum geht es bei der JavaScript-Validierung.

Sobald Sie sich entscheiden, einen regulären Ausdruck zur Validierung von E-Mails zu verwenden, müssen Sie etwas verstehen: 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 es sich bei der vom Benutzer eingegebenen E-Mail tatsächlich um eine E-Mail handelt, besteht darin, tatsächlich eine E-Mail zu senden und zu sehen, was passiert.Ansonsten sind das alles nur Vermutungen.

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 Verknüpfung

Von dem HTML5-Spezifikation:

A Gültige E-Mail-Adresse ist eine Zeichenfolge, die mit dem übereinstimmt email Produktion 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ätzlicher Verstoß von RFC 5322, der eine Syntax für E-Mail-Adressen definiert, die gleichzeitig zu streng (vor dem „@“-Zeichen), zu vage (nach dem „@“-Zeichen) und zu lax (Kommentare, Leerzeichen und Anführungszeichen zulässig) ist Zeichenfolgen auf eine für die meisten Benutzer ungewohnte Weise) 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 ermöglicht 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 (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)

Es ist eindeutig vielseitig und ermöglicht die wichtigen internationalen Zeichen, während es dennoch das grundlegende Format „anything@anything.anything“ durchsetzt.Es werden Leerzeichen blockiert, die von RFC technisch erlaubt sind, aber sie sind so selten, dass ich das gerne mache.

In modernen Browsern können Sie mit reinem JavaScript und dem auf der Antwort von @Sushil aufbauen 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 der Merkmalserkennung und der einfachen Validierung von Squirtles Antwort, es befreit Sie vom Massaker an regulären Ausdrücken und stört nicht bei alten Browsern.

JavaScript kann einen regulären Ausdruck abgleichen:

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)>)$

Dies ist die korrekte 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);
}

Alle E-Mail-Adressen enthalten ein „at“ (d. h.@)-Symbol.Testen Sie diese notwendige Bedingung:

email.indexOf("@") > 0

Kümmern Sie sich nicht um etwas Komplizierteres.Selbst wenn Sie genau bestimmen könnten, ob eine E-Mail RFC-syntaktisch gültig ist, würde Ihnen das nicht sagen, ob sie der Person gehört, die sie übermittelt hat.Das ist es, was wirklich zählt.

Um dies zu testen, senden Sie eine Validierungsnachricht.

Eine korrekte Validierung der E-Mail-Adresse gemäß den RFCs kann mit einem einzeiligen regulären Ausdruck nicht erreicht werden.Ein Artikel mit der besten Lösung, die ich in PHP gefunden habe, ist Was ist eine gültige E-Mail-Adresse?.Offensichtlich wurde es auf 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.

Eine gute Vorgehensweise besteht darin, Ihre Daten auf dem Client zu validieren, aber die Validierung auf dem Server noch einmal zu überprüfen.Vor diesem Hintergrund können Sie einfach auf dem Client prüfen, ob eine Zeichenfolge wie eine gültige E-Mail-Adresse aussieht, und die strenge Prü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:Zuletzt @ sollte vorletzte sein . seit @ kann nicht Teil des Servernamens sein (soweit ich weiß).

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

  • str.indexOf('@@') == -1:Es sollte nein geben @@ in der Adresse.Selbst wenn @ als letztes Zeichen im E-Mail-Benutzernamen erscheint, muss es in Anführungszeichen gesetzt werden " würde dazwischen liegen @ und der letzte @ in der Adresse.

  • lastDotPos > 2:Vor dem letzten Punkt sollten beispielsweise mindestens drei Zeichen stehen a@b.com.

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

Das wurde gestohlen 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;}

Ich freue mich wirklich darauf, dieses Problem zu lösen.Deshalb habe ich oben den regulären Ausdruck für die E-Mail-Validierung 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 weiterzugeben Wikipedia-E-Mail-Adresse.

Und Sie können das Ergebnis sehen Hier.

enter image description here

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, Dies ist ein Standard, den ALLE E-Mail-Adressen einhalten MÜSSEN.Und ich bin mir nicht sicher, warum Sie sich mit etwas „Einfacherem“ beschäftigen sollten ...Du wirst es sowieso kopieren und einfügen ;)

Wenn ich E-Mail-Adressen in der Datenbank speichere, schreibe ich sie oft in Kleinbuchstaben, und in der Praxis kann bei regulären Ausdrücken normalerweise die Groß-/Kleinschreibung nicht beachtet 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, bei dem die Groß-/Kleinschreibung nicht berücksichtigt wird). i Am 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') );

Notiz:
Technisch gesehen können einige E-Mails im Abschnitt vor dem Zitat Anführungszeichen enthalten @ Symbol mit Escape-Zeichen in den Anführungszeichen (damit Ihr E-Mail-Benutzer anstößig sein und Dinge enthalten kann wie @ Und "..." solange es in Anführungszeichen steht).NIEMAND TUT DAS NIEMAND!Es ist veraltet.Aber es IST im Wahren enthalten RFC 2822 Standard und wird hier weggelassen.

Mehr Info: http://www.regular-expressions.info/email.html

Sie sollten keine regulären Ausdrücke verwenden, um eine Eingabezeichenfolge zu validieren 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 nur 90 % der Fälle abdecken können, schreiben Sie etwas wie:

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

Sie können es verfeinern.Beispielsweise ist „aaa@“ gültig.Aber im Großen und Ganzen versteht man das Wesentliche.Und lass dich nicht mitreißen...Eine einfache 90 %-Lösung ist besser als eine 100 %-Lösung, die nicht funktioniert.

Die Welt braucht einfacheren Code ...

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

<input type="email"/>

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

Das ist wie Knotenvalidator macht es:

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

Es ist schwierig, einen E-Mail-Validator zu 100 % korrekt zu machen.Die einzige wirkliche Möglichkeit, dies zu korrigieren, besteht darin, eine Test-E-Mail an das Konto zu senden.Dennoch gibt es ein paar grundlegende Überprüfungen, die dabei helfen können, sicherzustellen, dass Sie etwas Vernünftiges erhalten.

Einige Dinge, die verbessert werden müssen:

Statt neu RegExp, versuchen Sie einfach, das zu schreiben regexp so raus:

if (reg.test(/@/))

Überprüfen Sie zweitens, ob nach dem ein Punkt steht @ unterschreiben Sie und stellen Sie sicher, dass zwischen den Zeichen Zeichen stehen @s und Punkte.

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

Sonst können Sie verwenden jQuery.Innere 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');
}

Typoskriptversion vollständig

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

Mehr Info https://git.io/vhEfc

Beste Regex aller Zeiten, die RFC5322 entspricht

[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 Lösung, die die Existenz der TLD nicht prüft, ist unvollständig.

Fast alle Antworten auf diese Fragen empfehlen die Verwendung von Regex zur Validierung von E-Mail-Adressen.Ich denke, Regex eignet sich nur für eine rudimentäre Validierung.Es scheint, dass es sich bei der Überprüfung der Validierung von E-Mail-Adressen tatsächlich um zwei verschiedene Probleme handelt:

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

Zum Beispiel, obwohl die Adresse example@example.ccc Wird den regulären Ausdruck übergeben, handelt es sich nicht um eine gültige E-Mail, weil ccc ist keine Top-Level-Domain der IANA.

2- Stellen Sie sicher, dass die E-Mail tatsächlich existiert: Um dies zu tun, die einzige Option Ist um den Benutzern eine E-Mail zu senden.

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

Genommen von http://fightingforalostcause.net/misc/2006/compare-email-regex.php am 1. Oktober 2010.

Aber das ignoriert natürlich die Internationalisierung.

Im Kontrast zu Eichhörnchen, hier ist eine komplexe Lösung, aber sie leistet hervorragende Arbeit bei der ordnungsgemäßen Validierung von E-Mails:

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 es wie folgt:

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

Hier ist eine sehr gute Diskussion über die Verwendung regulärer Ausdrücke zur Validierung von E-Mail-Adressen;"Vergleich der E-Mail-Adressenvalidierung regulärer Ausdrücke"

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

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

Mein Wissen über Reguläre Ausdrücke ist nicht so gut.Deshalb überprüfe ich zunächst die allgemeine Syntax mit einem einfachen regulären Ausdruck und überprüfe anschließend spezifischere Optionen mit anderen Funktionen.Das ist vielleicht nicht die beste technische Lösung, aber so bin ich viel flexibler und schneller.

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

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>

Der von Microsoft bereitgestellte reguläre Ausdruck ASP.NET MVC Ist

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

Wikipedia-Standard-Mail-Syntax:

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

Zeigen Sie diesen Test: https://regex101.com/r/LHJ9gU/1

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top