Ist meine grundlegende Prüfung einer E-Mail so ok?

[Enrico]

Hallo,

ich habe mir eine Plausibilitätsprüfung für eingegebene E-Mails überlegt, die soweit auch funktioniert.

Die Prüfung auf unzulässige Zeichen habe ich weggelassen, weil sich diese ja immer wieder mal ändern oder ergänzt werden können.

Kann ich den nachfolgenden Code besser oder schlanker programmieren?
Habt ihr Verbesserungsvorschläge?

  
var Fehlermeldung = new Array();  
  
function is_email (input)  
{  
   var Feldspezifischer_Fehler = "";  
  
   if (!is_empty (input))  
   {  
      if (typeof input !== "string")  
         input = to_string (input);  
  
      if (input.indexOf("@") == -1)  
         Feldspezifischer_Fehler += 'E-Mail-Adresse|Das "@"-Zeichen fehlt';  
      else  
      {  
         var Einzelteile = input.split("@");  
  
         if (Einzelteile.length != 2)  
            add_error (Feldspezifischer_Fehler, "E-Mail-Adresse", 'Es ist nur ein "@"-Zeichen zulässig');  
         else  
         {  
            var Name    = Einzelteile[0],  
                Domaene = Einzelteile[1];  
  
            if (Name.length < 1)  
               add_error (Feldspezifischer_Fehler, "E-Mail-Adresse", "Der Namensteil ist zu kurz");  
            else  
               if (Name.length > 64)  
                  add_error (Feldspezifischer_Fehler, "E-Mail-Adresse", "Der Namensteil ist zu lang");  
  
            if (Domaene.indexOf(".") == -1)  
               add_error (Feldspezifischer_Fehler, "E-Mail-Adresse", "Der Punkt im Domänenteil fehlt");  
            else  
            {  
               Einzelteile = Domaene.split(".");  
  
               if (Domaene.indexOf(".") <= 0)  
                  add_error (Feldspezifischer_Fehler, "E-Mail-Adresse", "Der Domänenteil darf nicht mit einem Punkt anfangen");  
  
               if (Einzelteile[Einzelteile.length - 1].length < 2)  
                  add_error (Feldspezifischer_Fehler, "E-Mail-Adresse", "Die Länderkennung ist zu kurz");  
            }  
  
            if (Domaene.length < 3)  
               add_error (Feldspezifischer_Fehler, "E-Mail-Adresse", "Der Domänenteil ist zu kurz");  
         }  
  
         if (input.length > 254)  
            add_error (Feldspezifischer_Fehler, "E-Mail-Adresse", "Die E-Mail-Adresse ist zu lang");  
      }  
  
      if (input.indexOf(".") == -1)  
            add_error (Feldspezifischer_Fehler, "E-Mail-Adresse", "Der Punkt vor dem Domänenteil oder der Domänenteil insgesamt fehlt");  
      else  
         if (input.indexOf(".") == 0)  
            add_error (Feldspezifischer_Fehler, "E-Mail-Adresse", "Der Namensteil darf nicht mit einem Punkt beginnen");  
         else  
            if (input.indexOf(".") == input.length)  
               add_error (Feldspezifischer_Fehler, "E-Mail-Adresse", "Der Domänenteil darf nicht mit einem Punkt enden");  
  
      if (Feldspezifischer_Fehler == "")  
         return true;  
  
      Fehlermeldung.push (Feldspezifischer_Fehler);  
  
      return false;  
   }  
}  
  
function is_empty (input)  
{  
   if (typeof input !== "undefined" || input !== null || input || 0 !== input.length)  
   {  
      input = input.replace (/^\s+\p{Cc}|\r|\n|\r\n|\s+\p{Cc}|\r|\n|\r\n$/g, "");  
  
      return (0 === input.length);  
   }  
}  
  
function to_string (input)  
{  
   if (!is_empty (input))  
   {  
      if (input.toString)  
         input = input.toString();  
      else  
         if (typeof input !== "string")  
            input += "";  
  
      return input;  
   }  
}  
  
function add_error (Feldspezifischer_Fehler, Rubrik, Fehler)  
{  
            if (Feldspezifischer_Fehler.indexOf(Rubrik) == -1)  
               return (Rubrik + "|" + Fehler);  
            else  
               return ("~" + Fehler);  
}  

Vielen Dank für eure Mithilfe!

Gruß,
Enrico

[Der Martin]

Hi,

ich habe mir eine Plausibilitätsprüfung für eingegebene E-Mails überlegt, ...

nein, offensichtlich nicht. Vielleicht für e-Mail-_Adressen_, aber nicht für die e-Mails selbst.
(Sorry, ich hatte zufällig noch ein paar Korinthen in Darm.)

Die Prüfung auf unzulässige Zeichen habe ich weggelassen, weil sich diese ja immer wieder mal ändern oder ergänzt werden können.

Die meisten restlichen Prüfungen kannst du eigentlich auch weglassen. Was bringt dir die Erkenntnis, dass eine Mailadresse formal korrekt ist? Ob sie gültig ist (d.h. mit einem existierenden Postfach verknüpft), weißt du davon noch lange nicht.

if (Domaene.indexOf(".") == -1)
               add_error (Feldspezifischer_Fehler, "E-Mail-Adresse", "Der Punkt im Domänenteil fehlt");

Lokale Mailadressen wie etwa root@localhost möchtest du ausschließen?

if (input.indexOf(".") == 0)
            add_error (Feldspezifischer_Fehler, "E-Mail-Adresse", "Der Namensteil darf nicht mit einem Punkt beginnen");
         else
            if (input.indexOf(".") == input.length)
               add_error (Feldspezifischer_Fehler, "E-Mail-Adresse", "Der Domänenteil darf nicht mit einem Punkt enden");

Diese zwei Regeln sind zwar theoretisch richtig, aber unbrauchbar. Zumindest GMX erlaubt nämlich Mailadressen mit einem Local Part, der mit Punkt endet (ich kenne jemanden, der eine Mailadresse in der Art von [e-mail] hat).

Und noch ein allgemeiner Tipp zur Nomenklatur: Die Mail-Standards (RFC) unterscheiden zwischen Local Part und Domain Part (oft auch Hostname), und was du "Länderkennung" nennst, ist korrekt die TLD (Top Level Domain). Denn die ist ja nicht unbedingt länderspezifisch, sondern kann ja auch .com oder .org oder .museum sein - und noch eine Reihe anderer Möglichkeiten.

So long,
 Martin

[Enrico]

Servus Martin,

Vielleicht für e-Mail-_Adressen_, aber nicht für die e-Mails selbst.

Natürlich, klar :-)

Was bringt dir die Erkenntnis, dass eine Mailadresse formal korrekt ist?

Das ist mein primäres Ziel an dieser Stelle. Ob die Adresse gültig ist oder nicht, werde ich dann über php umsetzen (oder die Umsetzung zumindest probieren).

Lokale Mailadressen wie etwa root@localhost möchtest du ausschließen?

Es handelt sich hierbei um die Anmeldung für unseren Newsletter, so dass ich davon ausgehe, dass nahezu alle eine E-Mail-Adresse in der Form [e-mail] verwenden dürften.

Zumindest GMX erlaubt nämlich Mailadressen mit einem Local Part, der mit Punkt endet

Dies führt diese spezielle Prüfung ad absurdum :-|

Und noch ein allgemeiner Tipp zur Nomenklatur

Hmmmm, würdest Du eine Prüfung auf formale Korrektheit dann komplett weg lassen?

Gruß,
Enrico

[Der Martin]

Hallo,

Ob die Adresse gültig ist oder nicht, werde ich dann über php umsetzen (oder die Umsetzung zumindest probieren).

es ist nicht zuverlässig möglich, das herauszufinden. Du kannst beim Versenden einer Nachricht an eine Adresse darauf achten, ob ein Fehler auftritt, z.B. der Server des angeblichen Empfängers die Nachricht abweist, weil das Postfach unbekannt ist.
Aber selbst wenn du die Nachricht ohne Fehler losgeworden bist, kann der Server immer noch später feststellen, dass er sie nicht zuordnen kann. Dann kann verschiedenes passieren: Entweder er generiert eine Fehler-Nachricht und schickt die an den Absender oder an die Reply-Adresse (Bounce Mail), oder er wirft sie in eine Sammelbox (Catch-All), über die sich der Admin freut.

Zumindest GMX erlaubt nämlich Mailadressen mit einem Local Part, der mit Punkt endet
Dies führt diese spezielle Prüfung ad absurdum :-|

Yep.

Hmmmm, würdest Du eine Prüfung auf formale Korrektheit dann komplett weg lassen?

Ja, würde ich. Ich würde sie weitgehend ungeprüft annehmen, und beim Versand von Nachrichten an diese gespeicherten Adressen auf Fehler achten. Wer dreimal hintereinander beim Versenden einen Fehler provoziert, fliegt wieder aus der Liste raus.

Andererseits musst du sowieso ein Double-Opt-In-Verfahren implementieren, um den Vorwurf des SPAM-Versands wirksam parieren zu können. Also etwa so:

1. Nutzer trägt e-Mail-Adresse für den Newsletter ein.
 2. Du sendest _einmalig_ eine Nachricht an diese Adresse. Darin weist du darauf hin,
    dass diese Adresse für den Newsletter eingetragen wurde, aber erst gültig übernommen
    wird, wenn innerhalb von z.B. 24 Stunden ein Bestätigungslink mit einer einmaligen
    ID aufgerufen wird.
 3. Wird der Bestätigungslink aufgerufen, markierst du die Adresse in der Liste als
    gültig; erfolgt in 24h keine Bestätigung, wird die Adresse wieder aus der Liste
    gelöscht.

So erledigt sich das Problem mit ungültigen Mailadressen von selbst.

Ciao,
 Martin

[Enrico]

Hallo Martin,

Ich würde sie weitgehend ungeprüft annehmen

Auf was würdest Du denn prüfen?

Das mit dem Double-Opt-In-Verfahren finde ich sehr interessant.

Gruß,
Enrico

[Matthias Apsel]

Om nah hoo pez nyeetz, Enrico!

Ich würde sie weitgehend ungeprüft annehmen
Auf was würdest Du denn prüfen?

Ich würde dem HTML5-Parser, oder wer auch immer dafür zuständig ist, prüfen lassen.

Das mit dem Double-Opt-In-Verfahren finde ich sehr interessant.

Du solltest das nicht nur interessant finden, sondern die Verfahrensweise auch so umsetzen. Damit schützt du dich vor Abmahnungen hinsichtlich des Versandes von nicht ausdrücklich angeforderten Mails (Spam).

Matthias

[Enrico]

Hallo Matthias,

ok, danke Dir, Martin & qx! :-)

Gruß,
Enrico

[dedlfix]

Tach!

2. Du sendest _einmalig_ eine Nachricht an diese Adresse.
3. [...] erfolgt in 24h keine Bestätigung, wird die Adresse wieder aus der Liste gelöscht.

Ich sehe da einen Widerspruch. Am Ende kommt jeden Tag eine Bestätigungsmail, weil nach dem Löschen ja nicht mehr bekannt ist, dass man dahin schon erfolglos Bestätigungen gesendet hat. Andererseits kann auch beim Empfänger was schiefgegangen sein, so dass er zwar will, aber den Bestätigungslink nicht klicken konnte und nun nicht wieder die Chance bekommt, bis ein Admin eingreift. Hier muss man abwägen, ob Spamschutz oder Nutzerkomfort wichtiger ist.

dedlfix.

[Quincunx]

Hallo Enrico,

verwendest du
<input type="email" name="mail" id="mail" value="" placeholder="gültige Email-Addresse" size="30"> (z.B.) als input-Feld?
Wenn ja kannst du dich ganz auf die serverseitige Validierung konzentrieren.

gruesse qx

[Enrico]

Hallo qx,

ja, ich verwende ein Textfeld oder habe ich Dich hier falsch verstanden?

Eine serverseitige Prüfung folgt natürlich auch noch.

Gruß,
Enrico

[Quincunx]

Hallo Enrico,

ja, ich verwende ein Textfeld oder habe ich Dich hier falsch verstanden?

[link:http://wiki.selfhtml.org/wiki/HTML/Formulare/Eingabefelder_und_Eingabebereiche/Input#type.3D.22email.22@title=type="email"]

[Frans]

Hallo.

ich habe mir eine Plausibilitätsprüfung für eingegebene E-Mails überlegt

Kann ich den nachfolgenden Code besser oder schlanker programmieren?
[drei Seiten Javascript mit einem Dutzend möglicher Fehlermeldungen]

Eine Prüfung an sich mag richtig und hilfreich sein, ich habe jedoch arge Zweifel, ob der Aufwand, den du treibst, gerechtfertigt ist.

Schon bei der Zuordnung des Begriffs "Namensteil" zur Struktur einer E-Mail-Adresse dürfte einem Gutteil der 08/15-Besucher zumindest für einen Augenblick das Fragezeichen im Gesicht stehen. Die "Länderkennung" wird noch weitaus größeres Rätselraten erzeugen (und das nicht nur, wenn jemand versucht, seine gmx.net-Adresse einem Land zuzuordnen) und beim "Domänenteil" garantiere ich dir für die Allgemeinheit, dass du 99% aller Besucher ratlos zurücklässt.

Die eine oder andere Fehlerquelle dürfte zudem nicht praxisrelevant sein, etwa die Möglichkeit, dass jemand als E-Mail-Adresse mehr als 256 Zeichen eintippt.

Die ganzen Fehlermeldungen sind sicher gut gemeint, aber sie werden unterm Strich kaum jemandem mehr weiterhelfen als ein banales "Bitte prüfen Sie die eingegebene E-Mail-Adresse": Die einen können mit den technischen Details nichts anfangen und der Rest sieht das Problem auch ohne detailierte Hinweise.

[Sven Rautenberg]

Moin!

Kann ich den nachfolgenden Code besser oder schlanker programmieren?
Habt ihr Verbesserungsvorschläge?

Aber ja.

Deine Prüfung ist mir viel zu detailliert. Der User wird mit diesen ganzen Details in der Regel nichts anfangen können. Der gibt seine Mailadresse ein - die kennt er. Und die ist gültig, sonst würde er sie nicht benutzen. Gelegentlich vertippen sich Menschen - dann ist das einzige sinnvolle Validierungsergebnis aber "Fehler in der Mailadresse", damit der User nochmal hinguckt, und seinen offensichtlichen Fehler hoffentlich findet. Die unoffensichtlichen Fehler findet nämlich auch dein Script nicht: "[e-mail]" beispielsweise ist falsch.

Ich habe lange Zeit einen sehr simplen regulären Ausdruck zum oberflächlichen Prüfen von Mailadressen propagiert: /.+@.+..+/
Mindestens ein Zeichen, ein At, dann wieder Zeichen, ein Punkt, und wieder Zeichen. Damit erschlägst du die formale Prüfung nach "sieht wie eine Mailadresse aus" relativ gut, ohne in die Details gehen zu müssen.

Das Input-Feld vom Typ "Email" macht das in den Browsern, die das schon umsetzen, noch viel schöner.

Da jegliche clientseitige Validierung kein Ersatz für eine serverseitige Validierung ist, kannst du dich bei den Details und den Prüfmöglichkeiten dort austoben. Da du aber eine formale Validierung der Mail sowieso nicht allein durchführen kannst, sondern für Newsletter immer die nachweisbare Zustimmung des Postfachinhabers für das weitere Zustellen des Newsletters brauchst, kommst du um das Double-Opt-In, also das Mailen eines Bestätigungslinks, sowieso nicht umhin. Und damit erschlägst du auch die Mailvalidierung nach formalen Regeln, denn Dinge wie Unzustellbarkeit wegen falscher Domain oder falschem Mailuser sind formal nicht ermittelbar.

- Sven Rautenberg

[Whouzuo]

Ich habe lange Zeit einen sehr simplen regulären Ausdruck zum oberflächlichen Prüfen von Mailadressen propagiert: /.+@.+..+/
Mindestens ein Zeichen, ein At, dann wieder Zeichen, ein Punkt, und wieder Zeichen. Damit erschlägst du die formale Prüfung nach "sieht wie eine Mailadresse aus" relativ gut, ohne in die Details gehen zu müssen.

UndWasIstMitMir@localhost

[M.]

Mahlzeit,

UndWasIstMitMir@localhost

Gibt es einen praktischen Anwendungsfall, bei dem eine solche Mailadresse geprüft werden muss?

[Whouzuo]

Mahlzeit,

UndWasIstMitMir@localhost

Gibt es einen praktischen Anwendungsfall, bei dem eine solche Mailadresse geprüft werden muss?

Ja, z.B. wenn sich der Admin zum testen selbst einträgt. ;)

[Sven Rautenberg]

Moin!

Ich habe lange Zeit einen sehr simplen regulären Ausdruck zum oberflächlichen Prüfen von Mailadressen propagiert: /.+@.+..+/
Mindestens ein Zeichen, ein At, dann wieder Zeichen, ein Punkt, und wieder Zeichen. Damit erschlägst du die formale Prüfung nach "sieht wie eine Mailadresse aus" relativ gut, ohne in die Details gehen zu müssen.

UndWasIstMitMir@localhost

...OHNE IN DIE DETAILS GEHEN ZU MÜSSEN! :)

- Sven Rautenberg

[hotti]

Moin Sven,

[..]

Full Ack.

Ich habe lange Zeit einen sehr simplen regulären Ausdruck zum oberflächlichen Prüfen von Mailadressen propagiert: /.+@.+..+/

Was auch recht einfach ist: split am @ und gucken ob für die beiden Strings mit
   encodeURI(string) == string
dasselbe rauskommt. Und wie im Thread hingewiesen, das HTML5-Attribut type="email" setzen, mehr würde ich im Browser auch nicht veranstalten.

MfG

[Gunnar Bittersmann]

@@hotti:

nuqneH

Was auch recht einfach ist: split am @ und gucken ob für die beiden Strings mit
   encodeURI(string) == string
dasselbe rauskommt.

Das ist völliger Unfug. Warum sollte da dasselbe rauskommen?

Für käthe@müller.example sind ('k%C3%A4the' == 'käthe') und ('m%C3%BCller.example' == 'müller.example') false.

Qapla'

[Kay]

Emails in Deutschland sammelt man mit einen Harvester :).

Nur Double-Opt-In-Verfahren.
Keine Trashmail Adressen zulassen.
Prüfen ob ausführbarer Code an die Adresse gehängt wurde oder weitere Adressen.
Prüfen auf verbotene Zeichen.

http://forum.de.selfhtml.org/archiv/2014/4/t217146/#m1490914

http://postmaster.gmx.de/

https://certified-senders.eu/wp-content/uploads/2014/03/Marketing-Richtlinie.pdf

Wenn man keinen Mailserver selber richtig betreiben kann, sollte man einen Dienstleister nehmen.
Aber auf die Zustellrate achten, es sind viele drittklassige Anbieter am Markt.