Der Einstieg lohnt sich also. Und weil das Ergebnis jeweils eine kleine Funktion ist, die Sie auch direkt in Abfragen einsetzen können, wächst mit jedem Muster Ihre eigene Werkzeugsammlung.<\/p>\n
Das RegExp-Objekt einbinden<\/h2>\n
Bis vor Kurzem gab es genau einen Weg: das Objekt VBScript.RegExp<\/b> aus der Bibliothek Microsoft VBScript Regular Expressions 5.5<\/b>, die hinter der Datei vbscript.dll<\/b> steckt. Sie binden es entweder über einen Verweis ein (frühe Bindung) oder erzeugen es zur Laufzeit über CreateObject<\/b> (späte Bindung). Den Verweis finden Sie im VBA-Editor unter Extras\/Verweise<\/b> – Bild 1 zeigt den entsprechenden Eintrag.<\/p>\n
![\"Der](\"..\/fileadmin\/_temp_\/2026_05\/pic_1616_001.png\")
<\/p>\n
Bild 1: Der Verweis auf die VBScript-Bibliothek im Verweise-Dialog<\/span><\/b><\/p>\n Genau diese Bibliothek verschwindet aber. Microsoft hat die Abkündigung von VBScript im Oktober 2023 angekündigt und im Mai 2024 einen Zeitplan in drei Phasen nachgeschoben. In der ersten Phase, die bis 2026 oder 2027 läuft, bleibt VBScript als optionales Feature vorinstalliert und aktiviert. In der zweiten Phase wird es standardmäßig deaktiviert, und in einer dritten Phase ohne festen Termin verschwindet es vollständig aus Windows. Spätestens dann können Anwendungen nicht mehr darauf vertrauen, dass die bisherige VBScript-RegExp-Bibliothek unter Windows verfügbar ist.<\/p>\n Die gute Nachricht: Das VBA-Team hat vorgesorgt. Ab Office-Version 2508 (Build 19127.20154) sind die RegExp-Klassen fest in VBA eingebaut<\/b> und stehen ohne jeden Verweis zur Verfügung. Sie können also einfach schreiben:<\/p>\n Ob Ihre Installation schon so weit ist, prüfen Sie am schnellsten mit einem Test im Direktbereich. Kompiliert die folgende Zeile ohne Fehler, sind die eingebauten Klassen vorhanden:<\/p>\n Alternativ werfen Sie einen Blick auf die Datei vbe7.dll<\/b> im Verzeichnis der gemeinsam genutzten Office-Komponenten. Ab der Dateiversion 7.1.11. sind die Klassen enthalten. Sollte die Office-Version stimmen, die Klassen aber trotzdem fehlen, hilft erfahrungsgemäß eine Schnellreparatur der Office-Installation.<\/p>\n Für Anwendungen, die Sie ausliefern, ergibt sich daraus eine klare Empfehlung: Verwenden Sie die späte Bindung.<\/b> Der Aufruf mit CreateObject<\/b> funktioniert sowohl auf älteren Systemen, auf denen VBScript noch aktiv ist, als auch auf neuen Office-Versionen ohne VBScript – er greift dort automatisch auf die eingebauten Klassen zu. Die frühe Bindung an die neu in VBA integrierte Klasse funktioniert dagegen erst ab Office-Version 2508. Auf älteren Versionen setzt sie weiterhin einen Verweis auf die VBScript-Bibliothek voraus.<\/p>\n Eine Entwarnung noch, weil die Frage regelmäßig aufkommt: Die Objekte Scripting.Dictionary<\/b> und Scripting.FileSystemObject<\/b> sind von der Abkündigung nicht<\/b> betroffen. Sie stammen aus der Bibliothek scrrun.dll<\/b> und bleiben erhalten – das hat der zuständige Produktmanager auf Nachfrage ausdrücklich bestätigt.<\/p>\n Das Objektmodell ist erfreulich übersichtlich.<\/p>\n Es besteht aus genau vier Klassen:<\/p>\n Bei der späten Bindung deklarieren Sie alle diese Variablen schlicht als Object<\/b>. Sie verlieren dadurch zwar IntelliSense, gewinnen aber die Lauffähigkeit auf allen Systemen.<\/p>\n Bevor wir suchen, stellen wir das Objekt ein. Es gibt genau vier Eigenschaften, und drei davon sind Schalter:<\/p>\n Damit haben wir alles beisammen, um die erste Suche zu starten.<\/p>\n Am einfachsten ist Test<\/b>. Die Methode liefert schlicht True<\/b> oder False<\/b> zurück, je nachdem, ob das Muster irgendwo im übergebenen Text vorkommt.<\/p>\n Das folgende Listing prüft, ob eine Zeichenkette ausschließlich eine fünfstellige Postleitzahl enthält.<\/p>\n Die Ausgabe im Direktbereich sieht so aus:<\/p>\n Der dritte Aufruf zeigt, wozu die beiden Anker gut sind. Das Dach am Anfang verlangt, dass der Treffer am Textanfang beginnt, das Dollarzeichen am Ende, dass er am Textende aufhört.<\/p>\n Ohne diese beiden Zeichen würde auch die dritte Zeile ein Wahr<\/b> liefern, weil die fünf Ziffern ja irgendwo im Text vorkommen. Das ist ein beliebter Fehler bei Prüffunktionen: Wer verifizieren will, dass ein Feld ausschließlich<\/b> aus dem gewünschten Muster besteht, muss beide Anker setzen.<\/p>\n Interessanter wird es, wenn wir wissen wollen, was<\/b> gefunden wurde. Dazu dient Execute<\/b>. Die Methode liefert eine MatchCollection<\/b> zurück, durch die wir schlicht mit For Each<\/b> laufen. Listing 1 sucht alle Zahlen in einem Freitext.<\/p>\n Listing 1: Alle Zahlen eines Textes ermitteln<\/span><\/b><\/p>\n Der Direktbereich meldet:<\/p>\n Zwei Beobachtungen. Erstens war hier Global = True<\/b> entscheidend – ohne diese Zeile hätten wir genau einen Treffer erhalten. Zweitens rechnen wir bei FirstIndex<\/b> eine Eins hinzu.<\/p>\n Die Eigenschaft ist nämlich nullbasiert, während Mid<\/b> und Left<\/b> in VBA bei Eins zu zählen beginnen. Wer diesen Versatz übersieht, schneidet konsequent ein Zeichen zu früh aus. Dass das Datum in drei Teile zerfällt, liegt natürlich am Muster: Wir haben Ziffernfolge<\/b> gesagt, nicht Datum<\/b>. Wie man das sauber formuliert, sehen wir gleich.<\/p>\n Eine Klammergruppe hat in einem regulären Ausdruck zwei Aufgaben. Sie fassen einen Teilausdruck zusammen, und sie merken sich, was an dieser Stelle gefunden wurde. Genau diese gemerkten Teile landen in der Auflistung SubMatches<\/b>. Damit zerlegen wir ein Datum in seine Bestandteile (siehe Listing 2).<\/p>\n Listing 2: Zerlegen eines Datums in Tag, Monat und Jahr<\/span><\/b><\/p>\n Beachten Sie die maskierten Punkte im Muster. Ein unmaskierter Punkt bedeutet nämlich ein beliebiges Zeichen<\/b> – wir wollen hier aber wirklich einen Punkt sehen. Der umgekehrte Schrägstrich davor nimmt dem Punkt seine Sonderbedeutung. Das Ergebnis:<\/p>\n Die dritte Methode ersetzt gefundene Stellen durch einen neuen Text. Der Clou dabei: Im Ersatztext können Sie mit $1<\/b> bis $9<\/b> auf die Klammergruppen zugreifen und mit $&<\/b> auf den gesamten Treffer. Damit lässt sich ein deutsches Datum in einem Rutsch in das ISO-Format überführen (siehe Listing 3).<\/p>\n Listing 3: Datumsangaben in das ISO-Format umschreiben<\/span><\/b><\/p>\n Der Aufruf DatumNachIso(„Rechnung vom 12.03.2026“)<\/b> liefert Rechnung vom 2026-03-12<\/b>. Die beiden Zeichenfolgen \\b an den Enden stehen jeweils für eine Wortgrenze und verhindern, dass mitten aus einer längeren Ziffernfolge heraus ersetzt wird.<\/p>\n Nun zur Sprache selbst. Sie besteht aus einer überschaubaren Zahl von Bausteinen.<\/p>\n Zunächst die Zeichenklassen, also Platzhalter für eine Gruppe von Zeichen:<\/p>\n Hier lauert eine Falle, die deutschsprachige Entwickler regelmäßig trifft: \\w umfasst nur die Zeichen A bis Z, a bis z, die Ziffern und den Unterstrich.<\/b> Umlaute und das scharfe S gehören nicht dazu. Ein Muster wie ^\\w+$<\/b> weist den Namen Müller<\/b> also zurück. Wer deutsche Namen prüfen will, muss die Zeichen ausdrücklich mit aufnehmen:<\/p>\n Der Bindestrich ist mit einem umgekehrten Schrägstrich maskiert, damit er nicht als Bereichsangabe interpretiert wird.<\/p>\n Als Nächstes die Quantoren, die angeben, wie oft der vorangehende Baustein vorkommen darf:<\/p>\n Dazu kommen die Anker und Gruppierungen:<\/p>\n Ein Punkt, der Anfänger zuverlässig zur Verzweiflung bringt: Quantoren arbeiten standardmäßig gierig<\/b>, greifen sich also so viel Text wie irgend möglich.<\/p>\n Wer aus einem HTML-Schnipsel den ersten Tag herauslösen will und dazu das Muster <.+><\/b> verwendet, bekommt nicht den ersten Tag, sondern alles vom ersten öffnenden bis zum letzten schließenden spitzen Klammerzeichen.<\/p>\n Abhilfe schafft ein Fragezeichen hinter dem Quantor. Es schaltet ihn auf genügsam um, sodass er sich mit dem kürzestmöglichen Treffer zufriedengibt. Das folgende Listing zeigt den Unterschied:<\/p>\n Die Ausgabe macht das Problem sofort sichtbar:<\/p>\n Merken Sie sich als Faustregel: Wenn ein Punkt mit Quantor nicht möglichst viel, sondern nur bis zur nächsten passenden Begrenzung erfassen soll, benötigen Sie in der Regel einen genügsamen Quantor wie .*? oder .+?.<\/p>\n Die Suchmaschine hinter RegExp<\/b> stammt aus der JScript-Welt und beherrscht deshalb einige Dinge nicht, die Sie aus Beispielen im Internet vielleicht kennen.<\/p>\n Damit Sie nicht lange nach dem Fehler suchen, hier die wichtigsten Lücken:<\/p>\n Alle bisherigen Beispiele brauchten vier bis fünf Zeilen Vorbereitung, bevor überhaupt gesucht wurde: Objekt erzeugen, Muster zuweisen, Optionen setzen, Suche starten.<\/p>\n Das ist zum Kennenlernen richtig, im Alltag aber lästig.<\/p>\n Deshalb kapseln wir die drei Methoden in drei Funktionen, die wir von nun an überall verwenden – auch im zweiten Teil dieser Reihe.<\/p>\n Alle drei folgen demselben Aufbau, damit man beim Wechsel zwischen ihnen nicht nachdenken muss:<\/p>\n Der dritte Punkt verdient eine Erläuterung, weil er in der Praxis den Unterschied macht. Eine Static<\/b>-Variable behält ihren Wert zwischen zwei Aufrufen der Funktion.<\/p>\n Setzen Sie eine dieser Funktionen als Kriterium in einer Abfrage über zehntausend Datensätze ein, wird sie zehntausendmal aufgerufen – ohne Static<\/b> würde dabei jedes Mal ein COM-Objekt erzeugt und gleich wieder verworfen. Mit Static<\/b> geschieht das genau einmal. Die Zuweisung des Musters erfolgt weiterhin bei jedem Aufruf, ist aber vergleichsweise billig.<\/p>\n Die erste Funktion namens RegExTest <\/b>kapselt die Methode Test<\/b> und liefert einen Wahrheitswert zurück (siehe Listing 4). Sie erwartet diese Parameter:<\/p>\n Listing 4: Kompakte Prüffunktion mit wiederverwendetem Objekt<\/span><\/b><\/p>\n Die Eigenschaft Global<\/b> steht hier bewusst auf False<\/b>. Uns interessiert ja nur, ob<\/b> es einen Treffer gibt – die Suche darf also beim ersten abbrechen und muss den restlichen Text gar nicht mehr ansehen. Ein Beispielaufruf mitsamt Ausgabe:<\/p>\n Der dritte Aufruf zeigt nebenbei, warum der Vorgabewert für blnIgnoreCase<\/b> manchmal stört: Das Muster verlangt einen Großbuchstaben am Anfang, aber weil wir die Groß- und Kleinschreibung standardmäßig ignorieren, würde auch müller<\/b> durchgehen.<\/p>\n Wenn die Schreibweise Teil der Prüfung ist, übergeben Sie im dritten Parameter ausdrücklich False<\/b>.<\/p>\n Die zweite Funktion namens RegExErsetzen <\/b>kapselt Replace<\/b> (siehe Listing 5). Sie kommt mit drei Parametern aus:<\/p>\n Listing 5: Die Ersetzungsfunktion RegExErsetzen<\/span><\/b><\/p>\n Anders als bei RegExTest<\/b> steht Global<\/b> hier fest auf True<\/b>, denn beim Ersetzen will man in aller Regel alle Vorkommen erwischen und nicht nur das erste. Soll ausnahmsweise nur die erste Fundstelle ersetzt werden, können Sie Global<\/b> über einen zusätzlichen optionalen Parameter steuerbar machen.<\/p>\nDim <\/span>objRegEx As <\/span>RegExp\r\nSet<\/span> objRegEx = New<\/span> RegExp<\/pre>\nDebug.Print<\/span> TypeName(New<\/span> RegExp)\r\nRegExp<\/pre>\nDim <\/span>objRegEx As Object<\/span>\r\nSet<\/span> objRegEx = CreateObject(\"VBScript.RegExp\")<\/pre>\nVier Klassen, mehr braucht es nicht<\/h2>\n
\n
Die vier Eigenschaften des RegExp-Objekts<\/h2>\n
\n
Die Methode Test: Passt das Muster?<\/h2>\n
Public Sub <\/span>TestPostleitzahl()\r\n Dim <\/span>objRegEx As Object<\/span>\r\n Set<\/span> objRegEx = CreateObject(\"VBScript.RegExp\")\r\n objRegEx.Pattern = \"^\\d{5}$\"\r\n Debug.Print<\/span> objRegEx.Test(\"47051\")\r\n Debug.Print<\/span> objRegEx.Test(\"4705\")\r\n Debug.Print<\/span> objRegEx.Test(\"47051 Duisburg\")\r\nEnd Sub<\/span><\/pre>\nWahr\r\nFalsch\r\nFalsch<\/pre>\n
Die Methode Execute: Was wurde gefunden?<\/h2>\n
Public Sub <\/span>ZahlenFinden()\r\n Dim <\/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>strText As String<\/span>\r\n strText = \"Bestellung 4711 vom 12.03.2026 über 3 Stueck zu je 19,90 Euro\"\r\n Set<\/span> objRegEx = CreateObject(\"VBScript.RegExp\")\r\n objRegEx.Pattern = \"\\d+\"\r\n objRegEx.Global = True<\/span>\r\n Set<\/span> objTreffer = objRegEx.Execute(strText)\r\n Debug.Print<\/span> \"Treffer: \" & objTreffer.Count\r\n For Each objMatch In objTreffer\r\n Debug.Print<\/span> objMatch.FirstIndex + 1, objMatch.Length, objMatch.Value\r\n Next<\/span> objMatch\r\nEnd Sub<\/span><\/pre>\nTreffer: 7\r\n12 4 4711\r\n22 2 12\r\n25 2 03\r\n28 4 2026\r\n39 1 3\r\n50 2 19\r\n53 2 90<\/pre>\n
Klammergruppen und SubMatches<\/h2>\n
Public Sub <\/span>DatumZerlegen()\r\n Dim <\/span>objRegEx As Object<\/span>\r\n Dim <\/span>objTreffer As Object<\/span>\r\n Dim <\/span>objMatch As Object<\/span>\r\n Set<\/span> objRegEx = CreateObject(\"VBScript.RegExp\")\r\n objRegEx.Pattern = \"(\\d{1,2})\\.(\\d{1,2})\\.(\\d{4})\"\r\n objRegEx.Global = True<\/span>\r\n Set<\/span> objTreffer = objRegEx.Execute( _\r\n \"Termine: 12.03.2026 und 5.4.2026\")\r\n For Each objMatch In objTreffer\r\n Debug.Print<\/span> \"Gesamt: \" & objMatch.Value\r\n Debug.Print<\/span> \" Tag: \" & objMatch.SubMatches(0)\r\n Debug.Print<\/span> \" Monat: \" & objMatch.SubMatches(1)\r\n Debug.Print<\/span> \" Jahr: \" & objMatch.SubMatches(2)\r\n Next<\/span> objMatch\r\nEnd Sub<\/span><\/pre>\nGesamt: 12.03.2026\r\n Tag: 12\r\n Monat: 03\r\n Jahr: 2026\r\nGesamt: 5.4.2026\r\n Tag: 5\r\n Monat: 4\r\n Jahr: 2026<\/pre>\n
Die Methode Replace<\/h2>\n
Public Function <\/span>DatumNachIso(ByVal strText As String<\/span>) As String<\/span>\r\n Dim <\/span>objRegEx As Object<\/span>\r\n Set<\/span> objRegEx = CreateObject(\"VBScript.RegExp\")\r\n objRegEx.Global = True<\/span>\r\n objRegEx.Pattern = \"\\b(\\d{2})\\.(\\d{2})\\.(\\d{4})\\b\"\r\n DatumNachIso = objRegEx.Replace<\/span>(strText, \"$3-$2-$1\")\r\nEnd Function<\/span><\/pre>\nDie Mustersprache im Überblick<\/h2>\n
\n
objRegEx.Pattern = \"^[A-Za-zÄÖÜäöüß\\- ]+$\"<\/pre>\n
\n
\n
Gierig oder genügsam?<\/h2>\n
Public Sub <\/span>GierigOderNicht()\r\n Dim <\/span>objRegEx As Object<\/span>\r\n Dim <\/span>strHtml As String<\/span>\r\n strHtml = \"<b>Hallo<\/b> <i>Welt<\/i>\"\r\n Set<\/span> objRegEx = CreateObject(\"VBScript.RegExp\")\r\n objRegEx.Pattern = \"<.+>\"\r\n Debug.Print<\/span> objRegEx.Execute(strHtml)(0).Value\r\n objRegEx.Pattern = \"<.+?>\"\r\n Debug.Print<\/span> objRegEx.Execute(strHtml)(0).Value\r\nEnd Sub<\/span><\/pre>\n<b>Hallo<\/b> <i>Welt<\/i>\r\n<b><\/pre>\n
Was diese Engine nicht kann<\/h2>\n
\n
Hilfsfunktionen für den Alltag<\/h2>\n
\n
RegExTest: Passt das Muster?<\/h2>\n
Public Function <\/span>RegExTest(ByVal strText As String<\/span>, ByVal strMuster As String<\/span>, Optional<\/span> ByVal blnIgnoreCase As <\/span>_\r\n Boolean = True<\/span>) As Boolean<\/span>\r\n Static <\/span>objRegEx As Object<\/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.IgnoreCase = blnIgnoreCase\r\n objRegEx.Global = False<\/span>\r\n RegExTest = objRegEx.Test(strText)\r\nEnd Function<\/span><\/pre>\n\n
Debug.Print<\/span> RegExTest(\"47051\", \"^\\d{5}$\")\r\nDebug.Print<\/span> RegExTest(\"D-47051\", \"^\\d{5}$\")\r\nDebug.Print<\/span> RegExTest(\"Müller\", \"^[A-ZÄÖÜ][a-zäöüß]+$\")\r\nWahr\r\nFalsch\r\nWahr<\/pre>\nRegExErsetzen: Suchen und ersetzen<\/h2>\n
Public Function <\/span>RegExErsetzen(ByVal strText As String<\/span>, ByVal strMuster As String<\/span>, ByVal strErsatz As String<\/span>) As String<\/span>\r\n Static <\/span>objRegEx As Object<\/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 RegExErsetzen = objRegEx.Replace<\/span>(strText, strErsatz)\r\nEnd Function<\/span><\/pre>\n\n