Immer mehr Vorgänge werden per E-Mail verarbeitet. Dazu gehören auch Bestellungen, Rechnungen et cetera. Früher wurden beispielsweise Rechnungen an die Postadresse geschickt, was einigermaßen fehlertolerant war. Spätestens der Briefträger hat die falsche Hausnummer erkannt und die Sendung dank regelmäßigem Zustellungsgebiet beim richtigen Adressaten abgeliefert. Bei E-Mails verhält sich dies völlig anders: Hier führt jede Ungenauigkeit zur Unzustellbarkeit, toleriert werden allenfalls noch Abweichungen bei der Groß-\/Kleinschreibung. Daher lohnt es sich, die E-Mail-Adressen von Kunden und anderen Adressaten zumindest oberflächlich zu prüfen.<\/b><\/p>\nAufbau einer E-Mail-Adresse<\/h2>\n
Als Erstes unterteilen wir eine E-Mail-Adresse grob in den Teil vor dem @-Zeichen und dahinter. Davor finden wir den sogenannten Lokalteil, dahinter die Domain des E-Mail-Providers.<\/p>\n
Schauen wir uns zuerst die Domain an. Diese besteht wiederum aus drei Teilen: dem Hostnamen, einem Punkt und der Top-Level-Domain. Da es immer mehr Top-Level-Domains gibt, wird es schwierig, diese konkret auf Gültigkeit zu prüfen. Auch die Anzahl der Zeichen wurde im Laufe der Zeit immer mehr ausgeweitet. Früher gab es nur Top-Level-Domains mit zwei oder drei Buchstaben (wie de <\/b>oder com<\/b>), mittlerweile finden wir auch solche mit mehr Buchstaben.<\/p>\n
Der Teil vor dem @-Zeichen heißt Lokalteil und kann je Domain nur einmal vergeben werden. Er kann die folgenden Zeichen verwenden:<\/p>\n
A-Za-z0-9.!#$%&''*+-\/=?^_''{|}~<\/pre>\nAllerdings finden wir in der Regel nur Buchstaben, Zahlen und den Punkt vor. Dennoch können wir die möglichen Zeichen in die Prüfung mit einbeziehen.<\/p>\n
Möglichkeiten für die Prüfung<\/h2>\n
Wir können verschiedene Techniken für die Prüfung von E-Mail-Adressen einsetzen. Wenn wir nur eine grundlegende Prüfung vornehmen wollen, kommen wir mit den Zeichenkettenfunktionen von VBA aus. Für eine weitergehende Prüfung ist auch die Nutzung von regulären Ausdrücken möglich. Dazu benötigen wir jedoch bereits eine zusätzliche Bibliothek. Diese beiden Methoden erlauben jedoch nur die Prüfung der Syntax der E-Mail-Adresse.<\/p>\n
Wenn Sie sicherstellen wollen, dass die E-Mail auch beim Empfänger ankommt, können Sie einen der zahlreichen Onlinedienste beanspruchen. Diese sind jedoch meist kostenpflichtig oder bieten keinen Webservice an, mit dem wir diese nutzen können.<\/p>\n
Grundlegende Prüfung<\/h2>\n
Die grundlegendste Prüfung kontrolliert schlicht, ob die E-Mail-Adresse bestimmte Elemente und keine unerlaubten Sonderzeichen enthält.<\/p>\n
Diese wollen wir nun per VBA programmieren. Die dazu notwendige Funktion soll CheckEMailSyntax <\/b>heißen und die zu prüfende E-Mail-Adresse als Parameter entgegennehmen. Das Ergebnis soll ein Boolean<\/b>-Wert sein, der im Falle einer gültigen E-Mail-Adresse den Wert True <\/b>enthält. Diese definieren wir zunächst wie folgt:<\/p>\nPublic Function <\/span>CheckEMailSyntax(strEMail As String<\/span>) As Boolean<\/span>\r\nEnd Function<\/span><\/pre>\nNun wollen wir ein paar Testfälle mit vorgegebenen Ergebnissen definieren, mit denen wir die Funktion direkt während der Entwicklung testen können. Dazu verwenden wir zwei verschiedene Prozeduren.<\/p>\n
Die erste ruft die eigentliche Testprozedur auf und übergibt dieser jeweils die zu untersuchende E-Mail-Adresse und die Angabe, ob diese gültig ist oder nicht. Hier sind die Aufrufe mit einigen Test-Adressen:<\/p>\n
Public Sub <\/span>Test()\r\n Test_CheckEMailSyntax \"andre@minhorst.com\", True<\/span>\r\n Test_CheckEMailSyntax \"andre@minhorst,com\", False<\/span>\r\n Test_CheckEMailSyntax \"andreQminhorst.com\", False<\/span>\r\n Test_CheckEMailSyntax \"andre@minhorst.de\", True<\/span>\r\n Test_CheckEMailSyntax \"@minhorst.de\", False<\/span>\r\n Test_CheckEMailSyntax \"andre@.de\", False<\/span>\r\n Test_CheckEMailSyntax \"andre@minhorst.\", False<\/span>\r\n Test_CheckEMailSyntax \"andre@minhorst@de\", False<\/span>\r\nEnd Sub<\/span><\/pre>\nDie zweite Prozedur führt den Testaufruf aus und gleicht das Ergebnis mit dem erwarteten Ergebnis ab. Liefert der Test das erwartete Ergebnis, erscheint eine Zeile im Direktbereich, die auf den erfolgreichen Test verweist.<\/p>\n
Anderenfalls wird der fehlgeschlagene Test gemeldet (siehe Listing 1).<\/p>\n
Public Sub <\/span>Test_CheckEMailSyntax(strEMail As String<\/span>, bolResult As Boolean<\/span>)\r\n If <\/span>CheckEMailSyntax(strEMail) = bolResult Then<\/span>\r\n Debug.Print<\/span> \"Test mit ''\" & strEMail & \"'' erfolgreich\"\r\n Else<\/span>\r\n Debug.Print<\/span> \"Test mit ''\" & strEMail & \"'' fehlgeschlagen\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nListing 1: Eigentliche Testprozedur<\/span><\/b><\/p>\nMit den obigen Tests sieht das Ergebnis wie folgt aus:<\/p>\n
Test mit ''andre@minhorst.com'' erfolgreich\r\nTest mit ''andre@minhorst,com'' erfolgreich\r\nTest mit ''andreQminhorst.com'' erfolgreich\r\nTest mit ''andre@minhorst.de'' erfolgreich\r\nTest mit ''@minhorst.de'' fehlgeschlagen\r\nTest mit ''andre@.de'' fehlgeschlagen\r\nTest mit ''andre@minhorst.'' fehlgeschlagen\r\nTest mit ''andre@minhorst@de'' erfolgreich<\/pre>\nZufälligerweise liefert die Funktion mit dem Wert False<\/b> in einigen Fällen das richtige Ergebnis, was sich aber gleich relativieren wird.<\/p>\n
Als Erstes wollen wir prüfen, ob ein @<\/b>-Zeichen in der E-Mail enthalten ist. Dazu erweitern wir die Funktion wie folgt:<\/p>\nPublic Function <\/span>CheckEMailSyntax(strEMail As String<\/span>) As Boolean<\/span>\r\n If <\/span>InStr<\/span>(1, strEMail, \"@\") = 0 Then<\/span>\r\n CheckEMailSyntax = False<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\n ''...\r\n ''weitere Prüfungen\r\n ''...\r\n CheckEMailSyntax = True<\/span>\r\nEnd Function<\/span><\/pre>\nHier prüfen wir mit der InStr<\/b>-Funktion, ob in strEMail <\/b>überhaupt ein @<\/b>-Zeichen enthalten ist. Rufen wir die Test<\/b>-Prozedur erneut auf, liefern nun andere Tests ein positives Ergebnis. Wenn die Bedingung falsch ist, also die Funktion nicht über Exit Function <\/b>verlassen wird, gibt die Funktion den Wert True <\/b>zurück.<\/p>\n
Aber die Prüfung ist nicht ganz korrekt, denn es soll nicht nur überhaupt ein @<\/b>-Zeichen enthalten sein, sondern genau eines. Wie können wir prüfen, ob genau ein @<\/b>-Zeichen vorhanden ist? Wir ersetzen dieses durch eine leere Zeichenkette und vergleichen dann die Länge mit der Länge des Originals. Der durch die folgende Bedingung ermittelte Unterschied muss 1 sein:<\/p>\nIf <\/span>Not<\/span> Len<\/span>(strEMail) - Len<\/span>(Replace<\/span>(strEMail, \"@\", \"\")) = 1 Then<\/span>\r\n CheckEMailSyntax = False<\/span>\r\n Exit Function<\/span>\r\nEnd If<\/span><\/pre>\n<\/p>\n
Als Nächstes fügen wir eine Bedingung hinzu, die auf das Vorhandensein des Punkts prüft. Im Gegensatz zum @-Zeichen kann die E-Mail-Adresse auch mehrere Punkte enthalten, wie zum Beispiel in andre.minhorst@t-online.de<\/b>. Allerdings darf nur ein Punkt hinter dem @<\/b>-Zeichen auftauchen. Wir schauen uns also nur den Teil hinter dem @<\/b>-Zeichen an.<\/p>\n
Dazu deklarieren wir eine Variable namens strDomain <\/b>und fügen den Teil hinter dem @<\/b>-Zeichen in diese Variable ein:<\/p>\nDim <\/span>strDomain As String<\/span>\r\n...\r\nstrDomain = Mid<\/span>(strEMail, InStr<\/span>(1, strEMail, \"@\") + 1)<\/pre>\nDanach führen wir für strDomain <\/b>und den Punkt die gleiche Prüfung wie oben für strEMail <\/b>und das @<\/b>-Zeichen durch und prüfen so, ob genau ein Punkt in strDomain <\/b>enthalten ist:<\/p>\nIf <\/span>Not<\/span> Len<\/span>(strDomain) - Len<\/span>(Replace<\/span>(strDomain, \".\", \"\")) = 1 Then<\/span>\r\n CheckEMailSyntax = False<\/span>\r\n Exit Function<\/span>\r\nEnd If<\/span><\/pre>\nDamit gelingen schon einmal die ersten vier Tests, also schauen wir uns an, was wir noch nicht berücksichtigt haben, dass der fünfte Test fehlschlägt. Hier testen wir auf @minhorst.com<\/b>, was das Ergebnis False <\/b>liefern sollte, aber die Prozedur liefert das Ergebnis True<\/b>.<\/p>\n
Wir müssen also vor dem @<\/b>-Zeichen noch mindestens ein weiteres Zeichen vorfinden. Dazu lesen wir den Teil vor dem @<\/b>-Zeichen in die Variable strLocal <\/b>ein:<\/p>\nDim <\/span>strLocal As String<\/span>\r\n...\r\nstrLocal = Left<\/span>(strEMail, InStr<\/span>(1, strEMail, \"@\") - 1)<\/pre>\nDanach können wir zunächst einmal prüfen, ob strLocal <\/b>mindestens die Länge 1 <\/b>aufweist:<\/p>\nIf <\/span>Len<\/span>(strLocal) = 0 Then<\/span>\r\n CheckEMailSyntax = False<\/span>\r\n Exit Function<\/span>\r\nEnd If<\/span><\/pre>\nDamit kommen wir zum nächsten Test, der fehlschlägt: andre@.de <\/b>liefert einen Fehler. Logisch: Hier fehlt der Hostname, also der Teil vor dem Punkt. Also nutzen wir zwei weitere Variablen, in denen wir den Hostnamen und die Top Level Domain speichern:<\/p>\nDim <\/span>strHostname As String<\/span>\r\nDim <\/span>strTLD As String<\/span><\/pre>\nDiese ermitteln wir aus strDomain<\/b> – für den Hostnamen bis zum ersten Punkt von hinten, für die Top Level Domain vom ersten Punkt von hinten an:<\/p>\nstrHostname = Left<\/span>(strDomain, InStrRev<\/span>(strDomain, \".\") - 1)\r\nstrTLD = Mid<\/span>(strDomain, InStrRev<\/span>(strDomain, \".\") + 1)<\/pre>\nDie Prüfung, ob ein Hostname enthalten ist, sieht so aus:<\/p>\n
If <\/span>Len<\/span>(strHostname) = 0 Then<\/span>\r\n CheckEMailSyntax = False<\/span>\r\n Exit Function<\/span>\r\nEnd If<\/span><\/pre>\nUnd auf die Gültigkeit der Top Level Domain, also dem hinteren Teil, testen wir so:<\/p>\n
If <\/span>Len<\/span>(strTLD) = 0 Then<\/span>\r\n CheckEMailSyntax = False<\/span>\r\n Exit Function<\/span>\r\nEnd If<\/span><\/pre>\nDamit sind nun alle Tests erfolgreich. Also können wir ein paar weitere Hürden in Form neuer Tests einbauen.<\/p>\n
Lokalteil auf ungültige Zeichen prüfen<\/h2>\n
Der Lokalteil darf laut Wikipedia die folgenden Zeichen enthalten:<\/p>\n
A-Za-z0-9.!#$%&''*+-\/=?^_''{|}~<\/pre>\nDiese legen wir für eine Konstante namens cstrLocal <\/b>fest:<\/p>\nConst cstrLocal As String<\/span> = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.!#$%&''*+-\/=?^_''{|}~\"<\/pre>\nDann fügen wir einen Test hinzu, wo der Lokalteil ein ungültiges Zeichen enthält – nämlich ein Anführungszeichen:<\/p>\n
Test_CheckEMailSyntax \"an\"\"dre@minhorst.com\", False<\/span><\/pre>\nIn der Prüfung für diesen Fall durchlaufen wir alle Zeichen des Lokalteils aus strLocal <\/b>und prüfen, ob das aktuelle Zeichen in den zulässigen Zeichen enthalten ist.<\/p>\n
Falls nicht, liefert der Test den Wert False<\/b>:<\/p>\nFor i = 1 To Len<\/span>(strLocal)\r\n If <\/span>InStr<\/span>(1, cstrLocal, Mid<\/span>(strLocal, i, 1)) = 0 Then<\/span>\r\n CheckEMailSyntax = False<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\nNext<\/span> i<\/pre>\nDamit verläuft auch dieser Test erfolgreich.<\/p>\n
Hostname und Domain auf ungültige Zeichen testen<\/h2>\n
Der Hostname und die Top Level Domain dürfen nur aus Buchstaben bestehen und der Hostname darf zusätzlich noch das Minuszeichen enthalten, also beispielsweise access-im-unternehmen<\/b>. Die Minuszeichen dürfen aber nicht am Anfang oder am Ende liegen, sondern nur zwischen zwei Buchstaben. Für den Hostnamen legen wir eine weitere Konstante namens cstrHostname <\/b>an, die nur alle Buchstaben, alle Zahlen und das Minuszeichen enthält:<\/p>\nConst cstrHostname As String<\/span> = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-\"<\/pre>\nDie Konstante cstrTLD <\/b>für die Top Level Domain enthält alle Buchstaben:<\/p>\nConst cstrTLD As String<\/span> = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\"<\/pre>\nIn den folgenden beiden Prüfungen untersuchen wir den Hostnamen und die Top Level Domain auf ungültige Zeichen:<\/p>\n
For i = 1 To Len<\/span>(strHostname)\r\n If <\/span>InStr<\/span>(1, cstrHostname, Mid<\/span>(strHostname, i, 1)) = 0 Then<\/span>\r\n CheckEMailSyntax = False<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\nNext<\/span> i\r\nFor i = 1 To Len<\/span>(strTLD)\r\n If <\/span>InStr<\/span>(1, cstrTLD, Mid<\/span>(strTLD, i, 1)) = 0 Then<\/span>\r\n CheckEMailSyntax = False<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\nNext<\/span> i<\/pre>\nDass das Minuszeichen nicht an erster oder letzter Stelle beim Hostnamen stehen darf, prüfen wir mit folgender Bedingung:<\/p>\n
If <\/span>Left<\/span>(strHostname, 1) = \"-\" Or Right<\/span>(strHostname, 1) = \"-\" Then<\/span>\r\n CheckEMailSyntax = False<\/span>\r\n Exit Function<\/span>\r\nEnd If<\/span><\/pre>\nDie folgenden weiteren Tests verlaufen damit alle erfolgreich:<\/p>\n
Test_CheckEMailSyntax \r\n \"info@access-im-unternehmen.de\", True<\/span>\r\nTest_CheckEMailSyntax \r\n \"info@-access-im-unternehmen.de\", False<\/span>\r\nTest_CheckEMailSyntax \"info@access-im-unternehmen-.de\", False<\/span><\/pre>\nPraxistest: Newsletterverteiler<\/h2>\n
Wenn Sie einen Newsletterverteiler haben oder andere Listen von E-Mail-Adressen, können Sie die soeben erstellte Funktion zum Testen von E-Mail-Adressen gleich einmal einem Praxistest unterziehen.<\/p>\n
Wir verwenden dabei beispielsweise die Prozedur aus Listing 2.<\/p>\n
Public Sub <\/span>EMailsTesten()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblNewsletterempfaenger\", dbOpenDynaset, dbSeeChanges)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n If <\/span>Not<\/span> CheckEMailSyntax(rst!EMail) Then<\/span>\r\n Debug.Print<\/span> rst!EMail\r\n End If<\/span>\r\n DoEvents\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nListing 2: Ausprobieren der Funktion mit größeren Mengen an E-Mail-Adressen<\/span><\/b><\/p>\nBeim Durchforsten der scheinbar fehlerhaften E-Mails fällt auf, dass wir aus Wikipedia einige falsche Regeln abgeleitet haben. Der erste Fehler: Der Hostname kann auch eine oder mehrere Subdomains enthalten, also noch weitere Punkte. Wir ermitteln den Hostnamen für die Variable strHostname<\/b> nicht durch Trennen des Domainteils an der Stelle des mit InStr <\/b>gefundenen Punktes, sondern am ersten Punkt von hinten:<\/p>\nstrHostname = Left<\/span>(strDomain, InStrRev<\/span>(strDomain, \".\") - 1)<\/pre>\nDer Hostname darf dann mehrere Punkte enthalten, die sich aber nicht am Anfang und am Ende befinden dürfen und es dürfen keine zwei Punkte direkt aufeinanderfolgen – sie müssen also zwei Teile des Domainnamens voneinander trennen.<\/p>\n
Dies prüfen wir mit den folgenden beiden Bedingungen ab. Die erste untersucht, ob mehr als ein Punkt hintereinander im Hostnamen enthalten ist:<\/p>\n
If <\/span>Len<\/span>(strHostname) - Len<\/span>(Replace<\/span>( strHostname, \"..\", \"\")) > 1 Then<\/span>\r\n CheckEMailSyntax = False<\/span>\r\n Exit Function<\/span>\r\nEnd If<\/span><\/pre>\nDie zweite kümmert sich um Punkte, die am Anfang oder am Ende angegeben wurden – dazu gehören dann beispielsweise auch zwei Punkte vor der Top-Level-Domain wie etwa bei andre@minhorst..com<\/b>:<\/p>\nIf <\/span>Left<\/span>(strHostname, 1) = \".\" Or Right<\/span>(strHostname, 1) = \".\" Then<\/span>\r\n CheckEMailSyntax = False<\/span>\r\n Exit Function<\/span>\r\nEnd If<\/span><\/pre>\nGleichzeitig müssen wir die Bedingung von weiter oben, wo wir maximal einen Punkt innerhalb von strDomain <\/b>erlaubt haben, ändern, sodass hier mindestens ein Punkt vorkommen muss (dass es nicht mehr als zwei werden, prüfen wir weiter oben):<\/p>\nIf <\/span>Not<\/span> Len<\/span>(strDomain) - Len<\/span>(Replace<\/span>(strDomain, \".\", \"\")) >= 1 Then<\/span>\r\n CheckEMailSyntax = False<\/span>\r\n Exit Function<\/span>\r\nEnd If<\/span><\/pre>\nDen Punkt müssen wir außerdem noch zur Konstanten cstrHostname <\/b>hinzufügen.<\/p>\n
Mit dieser Version konnten wir zumindest in einigen Tausend E-Mails aus dem E-Mail-Verteiler zuverlässig die ungültigen E-Mail-Adressen herausfiltern.<\/p>\n
Zusammenfassung und Ausblick<\/h2>\n
Die hier vorgestellte Funktion CheckEMailSyntax <\/b>können Sie nun beispielsweise zum Prüfen größerer Mengen von E-Mails nutzen, die in einer Tabelle gespeichert sind – siehe Beispiel der Prozedur EMailsTesten <\/b>weiter oben.<\/p>\n
Sie können die Funktion aber auch direkt bei der Eingabe von E-Mail-Adressen in das Textfeld eines Formulars prüfen und eine entsprechende Meldung ausgeben, wenn die E-Mail nicht den Anforderungen entspricht.<\/p>\n
Dazu hinterlegen Sie beispielsweise für das Ereignis Vor Aktualisierung <\/b>eines Textfelds namens txtEMail <\/b>den folgenden Code:<\/p>\n