Seit Office Version 2508 sind reguläre Ausdrücke direkt in die VBA-Objektbibliothek integriert. Damit entfällt der bisherige Umweg über einen externen Verweis auf die VBScript-Bibliothek. Dieser Artikel erklärt die Hintergründe dieser Änderung, stellt alle Klassen und ihre Mitglieder vor und zeigt anhand zahlreicher Beispiele, wie Du reguläre Ausdrücke in Deinen VBA-Projekten einsetzen kannst.<\/b><\/p>\n
Beispieldatenbank<\/h2>\n
Die Beispiele in diesem Artikel sind nicht an eine Datenbank gebunden. Du kannst alle Prozeduren und Funktionen in einem beliebigen Standardmodul einer Access-, Excel- oder Word-Datei anlegen und im Direktbereich aufrufen.<\/p>\n
Im Mai 2024 kündigte Microsoft die geplante Abschaffung von VBScript als Windows-Komponente an. Diese Nachricht löste unter VBA-Entwicklern erhebliche Unruhe aus, denn die bis dahin genutzte Klasse RegExp<\/b> war Bestandteil der Datei vbscript.dll<\/b>, die im Zuge der Abschaffung entfernt werden soll.<\/p>\n
Microsoft reagierte auf die Bedenken der Community: Mit Office Version 2508 (Build 19127.20154), veröffentlicht im September 2025, wurden die Klassen RegExp<\/b>, Match<\/b>, MatchCollection<\/b> und SubMatches<\/b> direkt in die VBA-Bibliothek aufgenommen.<\/p>\n
Es handelt sich um eine der ersten größeren Erweiterungen der VBA-Objektbibliothek seit vielen Jahren.<\/p>\n
Die neuen Klassen stehen nicht nur in Microsoft 365 zur Verfügung, sondern generell in Click-to-Run-Installationen von Office, die auf Version 2508 oder höher aktualisiert wurden. Dazu zählen auch viele Einzelplatzinstallationen von Office 2016, 2019, 2021 und 2024. Ausgenommen sind die LTSC-Versionen (Long Term Service Channel), da diese keine Feature-Updates erhalten.<\/p>\n
Du kannst im Objektkatalog des VBA-Editors überprüfen, ob die Klassen verfügbar sind: Öffne den Objektkatalog mit F2<\/b> und wähle in der Bibliotheksliste den Eintrag VBA<\/b>. Dort sollten die vier neuen Klassen RegExp<\/b>, Match<\/b>, MatchCollection<\/b> und SubMatches<\/b> erscheinen (siehe Bild 1).<\/p>\n
![\"Die](\"..\/fileadmin\/_temp_\/2026_02\/pic_508_001.png\")
<\/p>\n
Bild 1: Die neuen Elemente der VBA-Bibliothek<\/span><\/b><\/p>\n Durch die Integration in die VBA-Bibliothek kannst Du nun mit Early Binding arbeiten, ohne einen externen Verweis hinzuzufügen. Die Deklaration Dim rx As RegExp<\/b> funktioniert direkt, und Du erhältst IntelliSense-Unterstützung im VBA-Editor.<\/p>\n Du darfst nicht davon ausgehen, dass diese Klasse bereits überall verfügbar ist. Eventuell aktualisiert ein Kunde seine Office-Installation nicht regelmäßig und arbeitet noch mit einer Version, in der die RegExp-Klasse nicht in der VBA-Bibliothek enthalten ist – oder er verwendet eine ältere Runtime.<\/p>\n Die Klasse RegExp<\/b> ist das zentrale Objekt für die Arbeit mit regulären Ausdrücken.<\/p>\n Über ihre Eigenschaften konfigurierst Du das Suchverhalten, und über ihre Methoden führst Du die eigentliche Suche durch.<\/p>\n Eigenschaften der Klasse RegExp<\/b>:<\/p>\n Methoden der Klasse RegExp<\/b>:<\/p>\n Ein MatchCollection<\/b>-Objekt wird ausschließlich von der Methode Execute<\/b> der Klasse RegExp<\/b> erzeugt.<\/p>\n Es handelt sich um eine schreibgeschützte Auflistung von Match<\/b>-Objekten:<\/p>\n Am häufigsten wirst Du eine MatchCollection<\/b> mit For Each<\/b> durchlaufen. Alternativ ist auch eine Schleife mit For…Next<\/b> über den Index möglich.<\/p>\n Jedes Match<\/b>-Objekt repräsentiert einen einzelnen Treffer innerhalb der durchsuchten Zeichenkette. Alle Eigenschaften sind schreibgeschützt:<\/p>\n Die Klasse SubMatches<\/b> ist eine schreibgeschützte Auflistung von Zeichenketten.<\/p>\n Jeder Eintrag entspricht dem Text, der durch eine einfangende Gruppe im Suchmuster gefunden wurde.<\/p>\n Bevor wir zu den Beispielen kommen, hier eine kompakte Übersicht der wichtigsten Elemente der Muster-Syntax. Die Zeichen in einem regulären Ausdruck lassen sich in drei Kategorien einteilen: literale Zeichen, Metazeichen und Quantifizierer. Wir listen diese in den folgenden Abschnitten auf.<\/p>\n Zeichenklassen und Metazeichen:<\/b><\/p>\n Quantifizierer:<\/b><\/p>\n Anker und Gruppen:<\/b><\/p>\n Wir beginnen mit den grundlegenden Methoden der RegExp<\/b>-Klasse. Alle Prozeduren verwenden Early Binding, das heißt, Du benötigst mindestens Office Version 2508.<\/p>\n Die Methode Test gibt True<\/b> zurück, sobald das Muster irgendwo in der Zeichenkette gefunden wird.<\/p>\n In diesem Fall sucht das Muster \\d+<\/b> nach einer oder mehreren aufeinanderfolgenden Ziffern.<\/p>\n Beachte, dass Global<\/b> auf True<\/b> gesetzt werden muss, damit alle Treffer und nicht nur der erste ermittelt werden.<\/p>\n Die Eigenschaft FirstIndex<\/b> ist nullbasiert, Position 5 <\/b>entspricht also dem sechsten Zeichen:<\/p>\n Im folgenden Beispiel wollen wir alle Auftreten von Zahlenwerten durch XXX <\/b>ersetzen. Dazu stellen wir als Pattern \\d+ <\/b>ein, was nach einer oder mehreren aufeinanderfolgenden Ziffern sucht. Diese werden durch die Replace<\/b>-Methode jeweils durch XXX <\/b>ersetzt:<\/p>\n Einfangende Gruppen in runden Klammern ermöglichen es, Teile eines Treffers gezielt auszulesen. Die gefundenen Teile stehen anschließend in der SubMatches<\/b>-Auflistung des jeweiligen Match<\/b>-Objekts zur Verfügung:<\/p>\n Das Muster (\\d{2})\\.(\\d{2})\\.(\\d{4}) <\/b>enthält drei einfangende Gruppen für Tag, Monat und Jahr. Der Punkt muss mit \\. <\/b>maskiert werden, da er als Metazeichen sonst für ein beliebiges Zeichen stehen würde. Beachte, dass SubMatches(0) <\/b>den Tag liefert, nicht den Gesamttreffer. Der Gesamttreffer steht in der Eigenschaft Value <\/b>des Match<\/b>-Objekts.<\/p>\n In der Methode Replace kannst Du mit $1, $2 und so weiter auf den Inhalt der einfangenden Gruppen zugreifen. Das eröffnet mächtige Möglichkeiten zur Umstrukturierung von Texten:<\/p>\n Hier wird das deutsche Datumsformat TT.MM.JJJJ <\/b>in das ISO-Format JJJJ-MM-TT <\/b>überführt, indem die Reihenfolge der Gruppen im Ersetzungstext vertauscht wird.<\/p>\n Ein klassischer Anwendungsfall für reguläre Ausdrücke ist die Validierung von Benutzereingaben. Das folgende Beispiel prüft, ob eine Zeichenkette dem Aufbau einer E-Mail-Adresse entspricht.<\/p>\n Die Anker ^ <\/b>und $ <\/b>stellen sicher, dass die gesamte Zeichenkette dem Muster entsprechen muss und nicht nur ein Teil davon. Die Eigenschaft IgnoreCase<\/b> sorgt dafür, dass sowohl groß- als auch kleingeschriebene Domainendungen akzeptiert werden. Du kannst die Funktion im Direktbereich testen:<\/p>\n Reguläre Ausdrücke erlauben mit dem Pipe-Zeichen |<\/b> die Angabe von Alternativen. So lassen sich mehrere Muster in einer einzigen Suche zusammenfassen.<\/p>\n Die Wortgrenze \\b <\/b>am Anfang des Musters verhindert, dass zum Beispiel “Herrlich” als Treffer erkannt wird. Am Ende der Gruppe steht bewusst kein \\b<\/b>, da der Punkt hinter “Dr.” kein Wortzeichen ist und die Wortgrenze dort nicht greifen würde.<\/p>\n Die Eigenschaft Multiline<\/b> beeinflusst das Verhalten der Anker ^ <\/b>und $<\/b>. Standardmäßig stehen sie nur für den Anfang und das Ende der gesamten Zeichenkette. Mit Multiline = True<\/b> erkennen sie auch den Anfang und das Ende jeder einzelnen Zeile.<\/p>\nVorsicht in Kundenumgebungen<\/h2>\n
Die Klasse RegExp<\/h2>\n
\n
\n
Die Klasse MatchCollection<\/h2>\n
\n
Die Klasse Match<\/h2>\n
\n
Die Klasse SubMatches<\/h2>\n
\n
Kurzübersicht: Muster-Syntax<\/h2>\n
\n
\n
\n
Grundlegende Beispiele<\/h2>\n
Einfacher Test auf ein Muster<\/h2>\n
Public Sub <\/span>TestAufMuster()\r\n Dim <\/span>rx As <\/span>RegExp\r\n Set<\/span> rx = New<\/span> RegExp\r\n rx.Pattern = \"\\d+\"\r\n 'Prüft, ob Ziffern enthalten sind\r\n Debug.Print<\/span> rx.Test(\"Hallo 42\")\r\n 'Ausgabe: True<\/span>\r\n Debug.Print<\/span> rx.Test(\"Hallo Welt\")\r\n 'Ausgabe: False<\/span>\r\nEnd Sub<\/span><\/pre>\nAlle Treffer mit Execute ermitteln<\/h2>\n
Public Sub <\/span>AlleTreffer()\r\n Dim <\/span>rx As <\/span>RegExp\r\n Dim <\/span>colMatches As <\/span>MatchCollection\r\n Dim <\/span>objMatch As <\/span>Match\r\n Set<\/span> rx = New<\/span> RegExp\r\n rx.Pattern = \"\\d+\"\r\n rx.Global = True<\/span>\r\n Set<\/span> colMatches = rx.Execute(\"Art. 12, Art. 345\")\r\n Debug.Print<\/span> \"Treffer: \" & colMatches.Count\r\n 'Ausgabe: Treffer: 2\r\n For Each objMatch In colMatches\r\n Debug.Print<\/span> objMatch.Value & \" an Position \" _\r\n & objMatch.FirstIndex\r\n Next<\/span> objMatch\r\n 'Ausgabe:\r\n '12 an Position 5\r\n '345 an Position 14\r\nEnd Sub<\/span><\/pre>\nEinfaches Ersetzen mit Replace<\/h2>\n
Public Sub <\/span>EinfachesErsetzen()\r\n Dim <\/span>rx As <\/span>RegExp\r\n Dim <\/span>strResult As String<\/span>\r\n Set<\/span> rx = New<\/span> RegExp\r\n rx.Pattern = \"\\d+\"\r\n rx.Global = True<\/span>\r\n strResult = rx.Replace<\/span>(\"Art. 12, Art. 345\", \"XXX\")\r\n Debug.Print<\/span> strResult\r\n 'Ausgabe: Art. XXX, Art. XXX\r\nEnd Sub<\/span><\/pre>\nSubMatches: Gruppen auswerten<\/h2>\n
Public Sub <\/span>GruppenAuswerten()\r\n Dim <\/span>rx As <\/span>RegExp\r\n Dim <\/span>colMatches As <\/span>MatchCollection\r\n Dim <\/span>objMatch As <\/span>Match\r\n Set<\/span> rx = New<\/span> RegExp\r\n 'Datum im Format TT.MM.JJJJ\r\n rx.Pattern = \"(\\d{2})\\.(\\d{2})\\.(\\d{4})\"\r\n rx.Global = True<\/span>\r\n Set<\/span> colMatches = rx.Execute(\"Beginn: 15.03.2025, \" _\r\n & \"Ende: 30.06.2025\")\r\n For Each objMatch In colMatches\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>\nErsetzen mit Rückverweisen<\/h2>\n
Public Sub <\/span>DatumUmformatieren()\r\n Dim <\/span>rx As <\/span>RegExp\r\n Dim <\/span>strResult As String<\/span>\r\n Set<\/span> rx = New<\/span> RegExp\r\n rx.Pattern = \"(\\d{2})\\.(\\d{2})\\.(\\d{4})\"\r\n rx.Global = True<\/span>\r\n 'Deutsches in ISO-Format wandeln\r\n strResult = rx.Replace<\/span>(\"15.03.2025\", \"$3-$2-$1\")\r\n Debug.Print<\/span> strResult\r\n 'Ausgabe: 2025-03-15\r\nEnd Sub<\/span><\/pre>\nValidierung von Eingaben<\/h2>\n
Public Function <\/span>IstGueltigeEmail(strEmail As String<\/span>) _\r\n As Boolean<\/span>\r\n Dim <\/span>rx As <\/span>RegExp\r\n Set<\/span> rx = New<\/span> RegExp\r\n rx.IgnoreCase = True<\/span>\r\n rx.Pattern = \"^[\\w.+-]+@\" & \"[\\w-]+(\\.[\\w-]+)*\" _\r\n & \"\\.[a-z]{2,}$\"\r\n IstGueltigeEmail = rx.Test(strEmail)\r\nEnd Function<\/span><\/pre>\n'Im Direktbereich:\r\nDebug.Print<\/span> IstGueltigeEmail(\"test@example.com\")\r\n'Ausgabe: True<\/span>\r\nDebug.Print<\/span> IstGueltigeEmail(\"ungueltig@@test\")\r\n'Ausgabe: False<\/span><\/pre>\nMehrere Muster auf einen Blick<\/h2>\n
Public Sub <\/span>AlternativenSuchen() Dim rx As <\/span>RegExp Dim colMatches As <\/span>MatchCollection Dim objMatch As <\/span>Match Set<\/span> rx = New<\/span> RegExp rx.Pattern = \"\\b(Herr|Frau|Dr\\.)\" rx.Global = True<\/span> Set<\/span> colMatches = rx.Execute(\"Herr Meier und \" _ & \"Dr. Schmidt\") For Each objMatch In colMatches Debug.Print<\/span> objMatch.Value Next<\/span> objMatch 'Ausgabe: 'Herr 'Dr.End Sub<\/pre>\nMehrere Zeilen durchsuchen<\/h2>\n
Public Sub <\/span>MehrzeiligeSuche()\r\n Dim <\/span>rx As <\/span>RegExp\r\n Dim <\/span>strText As String<\/span>\r\n Dim <\/span>colMatches As <\/span>MatchCollection\r\n Dim <\/span>objMatch As <\/span>Match\r\n strText = \"Zeile eins\" & vbCrLf<\/span> & \"Zeile zwei\" _\r\n & vbCrLf<\/span> & \"Zeile drei\"\r\n