Im ersten Teil dieser Reihe haben wir das RegExp-Objekt eingebunden, seine vier Klassen kennengelernt und die Mustersprache durchgearbeitet. Nun wird es konkret. Dieser Beitrag liefert fertige Muster für die Prüfung von E-Mail-Adressen, Telefonnummern, Postleitzahlen und Kfz-Kennzeichen, dazu Funktionen zum Herauslösen von Daten aus Freitextfeldern, zum Bereinigen kopierter Texte und zum Füllen von Textvorlagen. Alle Beispiele setzen die drei Hilfsfunktionen aus dem ersten Teil voraus – und am Ende zeigen wir eine Falle, die eine Access-Anwendung zuverlässig zum Stillstand bringt.<\/b><\/p>\n
Muster gehören in Konstanten<\/h2>\n
Bevor wir loslegen, eine organisatorische Empfehlung: Legen Sie ein Standardmodul an, beispielsweise namens mdlRegExPatterns<\/b>, in dem alle Muster als Konstanten stehen (siehe Listing 1). Der Grund ist weniger die Schreibarbeit als die Wartung – wenn sich herausstellt, dass Ihr Muster für Telefonnummern eine Schreibweise nicht erkennt, wollen Sie das an genau einer Stelle korrigieren und nicht an mehreren anderen Stellen.<\/p>\n Listing 1: Die Muster gesammelt an einer Stelle<\/span><\/b><\/p>\n Beachten Sie den maskierten Bindestrich in den Zeichenklassen. Innerhalb eckiger Klammern hat der Bindestrich die Bedeutung eines Bereichs, weshalb wir ihm mit einem vorangestellten Schrägstrich diese Rolle nehmen. Alternativ dürfen Sie ihn auch unmaskiert an die letzte Position der Klasse setzen.<\/p>\n Die Muster prüfen jeweils nur den formalen Aufbau. Bei einer IBAN werden weder die länderspezifische Länge noch die Prüfziffer kontrolliert. Auch das Kennzeichenmuster deckt bewusst nur die üblichen deutschen Standard-, Elektro- und Historienkennzeichen ab. Saison-, Wechsel- und Sonderkennzeichen benötigen eigene Erweiterungen.<\/p>\n Vorweg eine Einordnung, die Ihnen später Ärger erspart: Ein regulärer Ausdruck, der wirklich jede nach den Internetstandards zulässige E-Mail-Adresse korrekt beurteilt, ist mehrere tausend Zeichen lang und in der Praxis kaum sinnvoll einzusetzen.<\/p>\n Ein pragmatisches Muster ist deshalb meist die bessere Wahl: Es fängt grobe Eingabefehler wie ein fehlendes At-Zeichen oder einen vergessenen Punkt in der Domain ab, bleibt aber verständlich und wartbar.<\/p>\n Was ein Muster grundsätzlich nicht leisten kann, ist die Prüfung, ob das Postfach tatsächlich existiert. Verlässlich klären lässt sich das nur über eine Bestätigungsnachricht.<\/p>\n Mit dieser Einschränkung im Hinterkopf eignet sich das Muster aus cstrRegExEMail<\/b> gut als Plausibilitätsprüfung:<\/p>\n Die Ausgabe im Direktbereich:<\/p>\n In einem Formular setzen Sie die Prüfung sinnvollerweise im Ereignis Vor Aktualisierung<\/b> des Textfelds ein. Wichtig ist die vorherige Prüfung auf einen leeren Wert: Ist die Eingabe optional, soll ein leergelassenes Feld nicht als ungültige E-Mail-Adresse beanstandet werden (siehe Listing 2).<\/p>\n Listing 2: Prüfung der E-Mail vor Aktualisierung des Steuerelements<\/span><\/b><\/p>\n Eine Einschränkung noch: In der Gültigkeitsregel eines Tabellenfelds lässt sich diese Prüfung nicht unterbringen, weil dort keine selbst geschriebenen Funktionen erlaubt sind. Sie gehört daher ins Formular – oder in eine Auswahlabfrage, mit der Sie den Bestand nachträglich auf fehlerhafte Werte untersuchen.<\/p>\n Telefonnummern sind der Klassiker unter den unsauberen Daten. In einer gewachsenen Tabelle finden sich Schreibweisen wie 0203\/1234567<\/b>, + 203 1234567<\/b>, (0203) 12 34 56 7<\/b> und 0203-1234567<\/b> nebeneinander. Ein Muster, das alle diese Varianten erkennt und gleichzeitig Unsinn zurückweist, wird schnell unübersichtlich.<\/p>\n Der praxistauglichere Weg besteht aus zwei Schritten: Zuerst prüfen wir grob auf erlaubte Zeichen, dann zählen wir die Ziffern. Das ist robuster als ein einzelnes Monstermuster und deutlich leichter zu warten (siehe Listing 3).<\/p>\n Listing 3: Zweistufige Prüfung einer Telefonnummer<\/span><\/b><\/p>\n Die zweite Zeile der Funktion ist gleich noch für etwas anderes gut. Der Ausdruck \\D<\/b> trifft alles, was keine Ziffer ist – und weil wir ihn durch einen Leerstring ersetzen, bleiben genau die Ziffern übrig.<\/p>\n Auf dieser Idee baut die Vereinheitlichung auf, mit der wir alle Nummern in das internationale Format überführen (siehe Listing 4).<\/p>\n Listing 4: Umwandlung in das internationale Format<\/span><\/b><\/p>\n Ein Testlauf zeigt, dass die vier eingangs genannten Schreibweisen alle beim gleichen Ergebnis landen. Hier die Aufrufe:<\/p>\n Das Ergebnis lautet einheitlich:<\/p>\n Genau das brauchen Sie, wenn Sie Dubletten finden oder Nummern an eine Telefonanlage übergeben wollen. Die Funktion setzt allerdings voraus, dass nationale Nummern mit einer führenden Null und internationale Nummern mit +<\/b> oder 00<\/b> gespeichert sind. Eine Nummer wie 2031234567<\/b> lässt sich ohne weitere Information keinem Land sicher zuordnen. Als Aktualisierungsabfrage über einen entsprechend geprüften Bestand räumt die Funktion in einem Durchgang auf.<\/p>\n Häufiger als das Prüfen ist das Extrahieren. In fast jeder gewachsenen Datenbank gibt es ein Bemerkungsfeld, in dem über Jahre Informationen gelandet sind, die eigentlich in eigene Felder gehören. Mit RegExGruppe<\/b> aus dem ersten Teil holen wir sie heraus.<\/p>\n Der Klassiker ist die Adresszeile, in der Postleitzahl und Ort zusammenstehen. Das Muster trennt beides und liefert je nach Parameter den einen oder den anderen Teil:<\/p>\n Ebenso oft gesucht: der Betrag in einem Text. Deutsche Beträge sind mit ihrem Punkt als Tausendertrennzeichen und dem Komma als Dezimaltrenner etwas eigenwillig, aber gut zu fassen. Der erste Teil des Musters beschreibt die Variante mit Tausenderpunkten, der zweite die ohne (siehe Listing 5).<\/p>\n Listing 5: Herauslösen eines Geldbetrags<\/span><\/b><\/p>\n Der Aufruf mit dem Text Rechnungsbetrag 1.234,50 Euro netto<\/b> liefert den Währungswert 1234,5 zurück. Beachten Sie die Reihenfolge der beiden Alternativen: Die Suchmaschine nimmt die erste, die passt – stünde die einfache Variante vorn, bekämen wir bei 1.234,50<\/b> nur die 234,50<\/b> zu sehen. Diese Reihenfolge ist bei Alternativen fast immer entscheidend, und der Fehler ist tückisch, weil das Ergebnis ja plausibel aussieht.<\/p>\n Bis hierhin haben wir immer nur den ersten Treffer geholt. Oft brauchen wir aber alle: sämtliche E-Mail-Adressen in einem Verteiler, alle Rechnungsnummern in einer Bemerkung, jeden Platzhalter einer Textvorlage. Dafür lohnt sich eine vierte Hilfsfunktion namens RegExAlleTreffer<\/b>, die wir zu den dreien aus dem ersten Teil stellen (siehe Listing 6). Sie folgt demselben Bauprinzip und erwartet diese Parameter:<\/p>\n Listing 6: Alle Fundstellen als Zeichenkette<\/span><\/b><\/p>\n Die Eigenschaft Global<\/b> steht hier zwingend auf True<\/b> – ohne sie liefert die Suche genau einen Treffer, und die ganze Funktion wäre sinnlos. Weil das Ergebnis eine einfache Zeichenkette ist, lässt sich die Funktion unmittelbar in der Feldliste einer Abfrage einsetzen.<\/p>\n Nehmen wir eine Aufgabe, die in der Praxis regelmäßig anfällt. Ein Mitarbeiter kopiert den Verteiler einer E-Mail in das Bemerkungsfeld eines Kundendatensatzes. Was dort ankommt, ist alles andere als einheitlich – mal mit Namen und spitzen Klammern, mal mit runden Klammern, getrennt durch Semikola, Kommata oder Zeilenumbrüche:<\/p>\n Für die Suche brauchen wir eine zweite Variante unseres E-Mail-Musters. Das Muster von weiter oben trägt die beiden Anker und beschreibt deshalb einen Text, der ausschließlich aus einer Adresse besteht.<\/p>\n Zum Herauslösen aus einem längeren Text müssen die Anker weg:<\/p>\n Das ist ein Punkt, an dem viele hängen bleiben, deshalb sei er ausdrücklich festgehalten: Prüfen und Extrahieren brauchen unterschiedliche Muster. Beim Prüfen wollen wir wissen, ob der gesamte Text eine Adresse ist – beim Extrahieren suchen wir Adressen irgendwo darin. Verwenden Sie versehentlich das verankerte Muster zum Suchen, finden Sie nie etwas; verwenden Sie das ankerlose Muster zum Prüfen, geht jeder Unsinn durch, der irgendwo ein Klammeraffe enthält.<\/p>\n Der Aufruf liefert dann eine saubere Liste:<\/p>\n Bemerkenswert ist, was die Funktion alles ignoriert hat: die Namen davor, die spitzen und runden Klammern, die unterschiedlichen Trennzeichen und die Zeilenumbrüche. Genau das ist die Stärke regulärer Ausdrücke gegenüber einer selbstgeschriebenen Zerlegung – wir mussten kein einziges dieser Sonderzeichen vorhersehen.<\/p>\n Für die Anzeige ist eine verkettete Zeichenkette ideal, für die Weiterverarbeitung nicht. Wenn wir jede Adresse einzeln in eine Tabelle schreiben oder als Empfänger an eine E-Mail hängen wollen, brauchen wir ein Array. Die Variante aus Listing 7 liefert genau das.<\/p>\n Listing 7: Die Trefferliste als Array<\/span><\/b><\/p>\n Der Rückgabewert im Fall ohne Treffer verdient Beachtung. Wir liefern mit Array()<\/b> ein leeres Array zurück, dessen obere Grenze bei -1 liegt. Eine anschließende Schleife von 0 bis UBound<\/b> läuft damit schlicht null Mal durch – ohne dass der Aufrufer den Sonderfall abfangen müsste. Hätten wir stattdessen Null<\/b> oder ein nicht dimensioniertes Array zurückgegeben, bräuchte jeder Aufruf eine zusätzliche Prüfung.<\/p>\n Nun setzen wir alles zusammen. Die folgende Funktion durchläuft alle Kunden mit einem gefüllten Bemerkungsfeld, holt daraus sämtliche Adressen und schreibt sie in eine Tabelle tblEMailAdressen<\/b> mit den Feldern KundeID<\/b> und EMail<\/b>. Dubletten überspringt sie (siehe Listing 8).<\/p>\n Listing 8: Adressen aus Freitext in eine eigene Tabelle überführen<\/span><\/b><\/p>\n Für drei Details lohnt sich ein zweiter Blick. Die Zuweisung CompareMode = 1<\/b> stellt das Dictionary auf einen Vergleich um, der Groß- und Kleinschreibung ignoriert – zusammen mit dem LCase<\/b> beim Einlesen erwischen wir damit auch Adressen, die in unterschiedlicher Schreibweise vorliegen. Beachten Sie außerdem, dass CompareMode<\/b> gesetzt sein muss, bevor<\/b> der erste Eintrag hinzugefügt wird.<\/p>\n Zweitens wirkt das Dictionary über den gesamten Durchlauf. Eine Adresse, die bei zwei Kunden auftaucht, landet also nur einmal in der Zieltabelle – beim erstgefundenen Kunden. Soll die Dublettenprüfung stattdessen nur innerhalb eines Kunden greifen, rufen Sie zu Beginn jedes Schleifendurchlaufs objBekannt.RemoveAll<\/b> auf.<\/p>\n Und drittens ein beruhigender Hinweis zum Scripting.Dictionary<\/b>: Es stammt aus der Bibliothek scrrun.dll<\/b> und ist von der im ersten Teil beschriebenen Abkündigung von VBScript nicht betroffen. Sie dürfen es also bedenkenlos weiterverwenden.<\/p>\n Manchmal interessiert uns gar nicht, was gefunden wurde, sondern nur, wie oft. Wie viele Adressen stecken in einer Bemerkung? Wie viele Platzhalter enthält eine Vorlage? Dafür genügt ein Einzeiler, der auf dem Array aufsetzt:<\/p>\n Weil das leere Array die obere Grenze -1<\/b> hat, liefert die Funktion im Fall ohne Treffer sauber den Wert 0 <\/b>zurück – ganz ohne Sonderbehandlung.<\/p>\n Damit lässt sich nun endlich die Frage beantworten, bei welchen Kunden überhaupt mehr als eine Adresse im Bemerkungsfeld steckt. Hier lauert allerdings eine Falle: In Abfragen können Sie keine VBA-Konstanten verwenden.<\/p>\n Access löst zwar Funktionsaufrufe auf, Konstanten aber nicht, und quittiert den Versuch mit der Meldung über eine undefinierte Funktion. Die Lösung ist eine winzige Funktion, die das Muster zurückliefert:<\/p>\n Und damit funktioniert die Auswertung wie erwartet:<\/p>\n Diese Abfrage ist übrigens ein hervorragender Ausgangspunkt, bevor Sie die Übernahme mit der Prozedur AdressenUebernehmen<\/b> tatsächlich starten. Sie zeigt Ihnen auf einen Blick, was die Funktion finden wird – und ob Ihr Muster vielleicht Dinge einsammelt, die gar keine Adressen sind.<\/p>\n Wenn Benutzer Texte aus Webseiten oder Word-Dokumenten in ein Memofeld kopieren, kommt allerlei mit: HTML-Auszeichnungen, geschützte Leerzeichen, doppelte Leerzeichen und Zeilenumbrüche. Drei kleine Funktionen räumen das auf.<\/p>\n Die erste ist ein Einzeiler und zugleich die nützlichste. Sie fasst jede Folge von Leerzeichen, Tabulatoren und Zeilenumbrüchen zu einem einzigen Leerzeichen zusammen und entfernt anschließend den Leerraum an den Enden:<\/p>\n Das Muster \\s+<\/b> trifft dabei alle Arten von Leerraum. Wollen Sie die Absätze erhalten und nur innerhalb der Zeilen aufräumen, verwenden Sie stattdessen Option Compare Database<\/span>\r\nOption Explicit<\/span>\r\nPublic <\/span>Const cstrRegExEMail As String<\/span> = _\r\n \"^[A-Za-z0-9_%+\\-]+(?:\\.[A-Za-z0-9_%+\\-]+)*\" & _\r\n \"@[A-Za-z0-9](?:[A-Za-z0-9\\-]*[A-Za-z0-9])?\" & _\r\n \"(?:\\.[A-Za-z0-9](?:[A-Za-z0-9\\-]*[A-Za-z0-9])?)+$\"\r\nPublic <\/span>Const cstrRegExPlzDe As String<\/span> = \"^\\d{5}$\"\r\nPublic <\/span>Const cstrRegExIban As String<\/span> = _\r\n \"^[A-Z]{2}\\d{2}[A-Z0-9]{11,30}$\"\r\nPublic <\/span>Const cstrRegExKennzeichen As String<\/span> = _\r\n \"^[A-ZÄÖÜ]{1,3}-[A-ZÄÖÜ]{1,2} ?\\d{1,4}[EH]?$\"\r\nPublic <\/span>Const cstrRegExUrl As String<\/span> = _\r\n \"^https?:\/\/[A-Za-z0-9]\" & _\r\n \"(?:[A-Za-z0-9\\-]*[A-Za-z0-9])?\" & _\r\n \"(?:\\.[A-Za-z0-9]\" & _\r\n \"(?:[A-Za-z0-9\\-]*[A-Za-z0-9])?)+\" & _\r\n \"(?::\\d{1,5})?(?:[\/#?][^\\s]*)?$\"<\/pre>\nRezept 1: E-Mail-Adressen prüfen<\/h2>\n
Debug.Print<\/span> RegExTest(\"andre@access-im-unternehmen.de\", _\r\n cstrRegExEMail)\r\nDebug.Print<\/span> RegExTest(\"andre@@example.de\", cstrRegExEMail)\r\nDebug.Print<\/span> RegExTest(\"andre.example.de\", cstrRegExEMail)<\/pre>\nWahr\r\nFalsch\r\nFalsch<\/pre>\n
Private Sub <\/span>txtEMail_BeforeUpdate(Cancel As Integer<\/span>)\r\n If <\/span>Len<\/span>(Nz(Me.txtEMail, \"\")) = 0 Then<\/span> Exit Sub<\/span>\r\n If <\/span>Not<\/span> RegExTest(Me.txtEMail, cstrRegExEMail) Then<\/span>\r\n MsgBox<\/span> \"Bitte geben Sie eine gültige E-Mail-Adresse ein.\", vbExclamation\r\n Cancel = True<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nRezept 2: Telefonnummern prüfen und vereinheitlichen<\/h2>\n
Public Function <\/span>IstTelefonnummer(ByVal strNummer As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>strZiffern As String<\/span>\r\n ' Nur erlaubte Zeichen?\r\n If <\/span>Not<\/span> RegExTest(strNummer, \"^[\\d \\-\/\\(\\)\\+]+$\") Then<\/span> Exit Function<\/span>\r\n ' Wie viele Ziffern bleiben übrig?\r\n strZiffern = RegExErsetzen(strNummer, \"\\D\", \"\")\r\n IstTelefonnummer = (Len<\/span>(strZiffern) >= 6) And (Len<\/span>(strZiffern) <= 15)\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>TelefonNormalisieren(ByVal strNummer As String<\/span>, Optional<\/span> ByVal strLand As String<\/span> = \"\") As String<\/span>\r\n Dim <\/span>strZiffern As String<\/span>\r\n strZiffern = RegExErsetzen(strNummer, \"\\D\", \"\")\r\n If <\/span>Left<\/span>(strZiffern, 2) = \"00\" Then<\/span>\r\n ' 00203... -> 203...\r\n strZiffern = Mid<\/span>(strZiffern, 3)\r\n Else<\/span>If Left<\/span>(strZiffern, 1) = \"0\" Then\r\n ' 0203... -> 203...\r\n strZiffern = strLand & Mid<\/span>(strZiffern, 2)\r\n End If<\/span>\r\n TelefonNormalisieren = \"+\" & strZiffern\r\nEnd Function<\/span><\/pre>\nDebug.Print<\/span> TelefonNormalisieren(\"0203\/1234567\")\r\nDebug.Print<\/span> TelefonNormalisieren(\"+ 203 1234567\")\r\nDebug.Print<\/span> TelefonNormalisieren(\"(0203) 12 34 56 7\")\r\nDebug.Print<\/span> TelefonNormalisieren(\"0203-1234567\")<\/pre>\n+2031234567\r\n+2031234567\r\n+2031234567\r\n+2031234567<\/pre>\n
Rezept 3: Daten aus Freitext herauslösen<\/h2>\n
Public Function <\/span>PlzAusAdresse( _\r\n ByVal strZeile As String<\/span>) As String<\/span>\r\n PlzAusAdresse = RegExGruppe(strZeile, _\r\n \"\\b(\\d{5})\\s+(.+)$\", 1)\r\nEnd Function<\/span>\r\nPublic Function <\/span>OrtAusAdresse( _\r\n ByVal strZeile As String<\/span>) As String<\/span>\r\n OrtAusAdresse = RegExGruppe(strZeile, _\r\n \"\\b(\\d{5})\\s+(.+)$\", 2)\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>BetragAusText(ByVal strText As String<\/span>) As Variant<\/span>\r\n Dim <\/span>strTreffer As String<\/span>\r\n strTreffer = RegExGruppe(strText, \"\\d{1,3}(?:\\.\\d{3})+,\\d{2}|\\d+,\\d{2}\", 0)\r\n If <\/span>Len<\/span>(strTreffer) = 0 Then<\/span>\r\n BetragAusText = Null\r\n Else<\/span>\r\n BetragAusText = CCur(strTreffer)\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>RegExAlleTreffer(ByVal strText As String<\/span>, ByVal strMuster As String<\/span>, _\r\n Optional<\/span> ByVal strTrenner As String<\/span> = \"; \") As String<\/span>\r\n Static <\/span>objRegEx As Object<\/span>\r\n Dim <\/span>objTreffer As Object<\/span>\r\n Dim <\/span>objMatch As Object<\/span>\r\n Dim <\/span>strErgebnis As String<\/span>\r\n If <\/span>objRegEx Is Nothing Then<\/span>\r\n Set<\/span> objRegEx = CreateObject(\"VBScript.RegExp\")\r\n End If<\/span>\r\n objRegEx.Pattern = strMuster\r\n objRegEx.Global = True<\/span>\r\n objRegEx.IgnoreCase = True<\/span>\r\n Set<\/span> objTreffer = objRegEx.Execute(strText)\r\n For Each objMatch In objTreffer\r\n If <\/span>Len<\/span>(strErgebnis) > 0 Then<\/span>\r\n strErgebnis = strErgebnis & strTrenner\r\n End If<\/span>\r\n strErgebnis = strErgebnis & objMatch.Value\r\n Next<\/span> objMatch\r\n RegExAlleTreffer = strErgebnis\r\nEnd Function<\/span><\/pre>\n\n
Ein durchgehendes Beispiel: die Verteilerliste<\/h2>\n
Dim <\/span>strVerteiler As String<\/span>\r\nstrVerteiler = _\r\n \"Anna Meier <a.meier@example.de>; \" & _\r\n \"Bernd Schulz (b.schulz@example.de), \" & vbCrLf<\/span> & _\r\n \"c.mueller@example.de;\" & vbCrLf<\/span> & _\r\n \"Dieter Weiß <d.weiss@beispiel.at>\"<\/pre>\nPublic <\/span>Const cstrRegExAdresse As String<\/span> = _\r\n \"[A-Za-z0-9._%+\\-]+@[A-Za-z0-9.\\-]+\\.[A-Za-z]{2,}\"<\/pre>\nDebug.Print<\/span> RegExAlleTreffer(strVerteiler, _\r\n cstrRegExAdresse)\r\na.meier@example.de; b.schulz@example.de;\r\nc.mueller@example.de; d.weiss@beispiel.at<\/pre>\nVon der Zeichenkette zum Array<\/h2>\n
Public Function <\/span>RegExTrefferArray(ByVal strText As String<\/span>, ByVal strMuster As String<\/span>) As Variant<\/span>\r\n Static <\/span>objRegEx As Object<\/span>\r\n Dim <\/span>objTreffer As Object<\/span>\r\n Dim <\/span>strErgebnis() As String<\/span>\r\n Dim <\/span>i As Long<\/span>\r\n If <\/span>objRegEx Is Nothing Then<\/span>\r\n Set<\/span> objRegEx = CreateObject(\"VBScript.RegExp\")\r\n End If<\/span>\r\n objRegEx.Pattern = strMuster\r\n objRegEx.Global = True<\/span>\r\n objRegEx.IgnoreCase = True<\/span>\r\n Set<\/span> objTreffer = objRegEx.Execute(strText)\r\n ' Kein Treffer: leeres Array zurueckgeben\r\n If <\/span>objTreffer.Count = 0 Then<\/span>\r\n RegExTrefferArray = Array()\r\n Exit Function<\/span>\r\n End If<\/span>\r\n ReDim strErgebnis(objTreffer.Count - 1)\r\n For i = 0 To objTreffer.Count - 1\r\n strErgebnis(i) = objTreffer(i).Value\r\n Next<\/span> i\r\n RegExTrefferArray = strErgebnis\r\nEnd Function<\/span><\/pre>\nDie Adressen in eine Tabelle übernehmen<\/h2>\n
Public Function <\/span>AdressenUebernehmen() As Long<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rstQuelle As <\/span>DAO.Recordset\r\n Dim <\/span>rstZiel As <\/span>DAO.Recordset\r\n Dim <\/span>objBekannt As Object<\/span>\r\n Dim <\/span>varTreffer As Variant<\/span>\r\n Dim <\/span>strAdresse As String<\/span>\r\n Dim <\/span>lngNeu As Long<\/span>\r\n Dim <\/span>i As Long<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> objBekannt = CreateObject(\"Scripting.Dictionary\")\r\n objBekannt.CompareMode = 1\r\n Set<\/span> rstQuelle = db.OpenRecordset(\"SELECT KundeID, Notiz FROM tblKunden \" & \"WHERE Notiz Is Not<\/span> Null\")\r\n Set<\/span> rstZiel = db.OpenRecordset(\"tblEMailAdressen\", dbOpenDynaset, dbAppendOnly)\r\n Do While<\/span> Not<\/span> rstQuelle.EOF\r\n varTreffer = RegExTrefferArray(rstQuelle!Notiz, cstrRegExAdresse)\r\n For i = 0 To UBound<\/span>(varTreffer)\r\n strAdresse = LCase(varTreffer(i))\r\n If <\/span>Not<\/span> objBekannt.Exists(strAdresse) Then<\/span>\r\n objBekannt.Add strAdresse, True<\/span>\r\n rstZiel.AddNew<\/span>\r\n rstZiel!KundeID = rstQuelle!KundeID\r\n rstZiel!EMail = strAdresse\r\n rstZiel.Update\r\n lngNeu = lngNeu + 1\r\n End If<\/span>\r\n Next<\/span> i\r\n rstQuelle.MoveNext<\/span>\r\n Loop<\/span>\r\n rstZiel.Close\r\n rstQuelle.Close\r\n Set<\/span> rstZiel = Nothing\r\n Set<\/span> rstQuelle = Nothing\r\n AdressenUebernehmen = lngNeu\r\nEnd Function<\/span><\/pre>\nNur zählen statt sammeln<\/h2>\n
Public Function <\/span>RegExAnzahl( _\r\n ByVal strText As String<\/span>, _\r\n ByVal strMuster As String<\/span>) As Long<\/span>\r\n RegExAnzahl = UBound<\/span>( _\r\n RegExTrefferArray(strText, strMuster)) + 1\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>MusterAdresse() As String<\/span>\r\n MusterAdresse = cstrRegExAdresse\r\nEnd Function<\/span><\/pre>\nSELECT KundeID, Notiz,\r\n RegExAnzahl(Notiz, MusterAdresse()) AS Adressen,\r\n RegExAlleTreffer(Notiz, MusterAdresse()) AS Liste\r\nFROM tblKunden\r\nWHERE RegExAnzahl(Notiz, MusterAdresse()) > 1<\/pre>\n
Rezept 4: Texte bereinigen<\/h2>\n
Public Function <\/span>LeerraumNormalisieren( _\r\n ByVal strText As String<\/span>) As String<\/span>\r\n LeerraumNormalisieren = Trim<\/span>( _\r\n RegExErsetzen(strText, \"\\s+\", \" \"))\r\nEnd Function<\/span><\/pre>\n