Reguläre Ausdrücke in VBA: Die neue RegExp-Klasse

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.

Beispieldatenbank

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.

Warum jetzt diese Änderung?

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 war Bestandteil der Datei vbscript.dll, die im Zuge der Abschaffung entfernt werden soll.

Microsoft reagierte auf die Bedenken der Community: Mit Office Version 2508 (Build 19127.20154), veröffentlicht im September 2025, wurden die Klassen RegExp, Match, MatchCollection und SubMatches direkt in die VBA-Bibliothek aufgenommen.

Es handelt sich um eine der ersten größeren Erweiterungen der VBA-Objektbibliothek seit vielen Jahren.

Welche Office-Versionen sind betroffen?

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.

Du kannst im Objektkatalog des VBA-Editors überprüfen, ob die Klassen verfügbar sind: Öffne den Objektkatalog mit F2 und wähle in der Bibliotheksliste den Eintrag VBA. Dort sollten die vier neuen Klassen RegExp, Match, MatchCollection und SubMatches erscheinen (siehe Bild 1).

Bild 1: Die neuen Elemente der VBA-Bibliothek

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 funktioniert direkt, und Du erhältst IntelliSense-Unterstützung im VBA-Editor.

Vorsicht in Kundenumgebungen

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.

Die Klasse RegExp

Die Klasse RegExp ist das zentrale Objekt für die Arbeit mit regulären Ausdrücken.

Über ihre Eigenschaften konfigurierst Du das Suchverhalten, und über ihre Methoden führst Du die eigentliche Suche durch.

Eigenschaften der Klasse RegExp:

• Pattern (String, Lesen/Schreiben): Das Suchmuster als regulärer Ausdruck. Diese Eigenschaft muss vor dem Aufruf einer Methode gesetzt werden.
• Global (Boolean, Lesen/Schreiben): Bestimmt, ob alle Treffer oder nur der erste Treffer gesucht werden. Der Standardwert ist False, es wird also nur der erste Treffer ermittelt.
• IgnoreCase (Boolean, Lesen/Schreiben): Steuert, ob die Suche zwischen Groß- und Kleinschreibung unterscheidet. Der Standardwert ist False, die Suche ist also standardmäßig empfindlich gegenüber der Schreibweise.
• Multiline (Boolean, Lesen/Schreiben): Legt fest, ob die Anker ^ und $ nur am Anfang und Ende der gesamten Zeichenkette wirken oder auch am Anfang und Ende jeder einzelnen Zeile. Der Standardwert ist False.

Methoden der Klasse RegExp:

• Test(Zeichenkette): Gibt True zurück, wenn das Muster in der übergebenen Zeichenkette gefunden wird, andernfalls False. Die Eigenschaft Global hat auf das Ergebnis keinen Einfluss.
• Execute(Zeichenkette): Durchsucht die übergebene Zeichenkette und gibt ein MatchCollection-Objekt zurück, das alle gefundenen Treffer enthält (beziehungsweise nur den ersten, wenn Global auf False steht).
• Replace(Zeichenkette, Ersetzung): Ersetzt die gefundenen Treffer in der Zeichenkette durch den angegebenen Ersetzungstext und gibt das Ergebnis als neue Zeichenkette zurück. In der Ersetzung kannst Du mit $1, $2 und so weiter auf eingefangene Gruppen zugreifen. Mit $& fügst Du den gesamten Treffer ein.

Die Klasse MatchCollection

Ein MatchCollection-Objekt wird ausschließlich von der Methode Execute der Klasse RegExp erzeugt.

Es handelt sich um eine schreibgeschützte Auflistung von Match-Objekten:

• Count (Long, nur Lesen): Die Anzahl der gefundenen Treffer. Wenn kein Treffer gefunden wurde, ist der Wert 0.
• Item(Index) (Match, nur Lesen): Gibt den Treffer an der angegebenen Position zurück. Der Index beginnt bei 0 und reicht bis Count – 1. Da Item die Standardeigenschaft ist, kannst Du auch die Kurzform MatchCollection(0) verwenden.

Am häufigsten wirst Du eine MatchCollection mit For Each durchlaufen. Alternativ ist auch eine Schleife mit For…Next über den Index möglich.

Die Klasse Match

Jedes Match-Objekt repräsentiert einen einzelnen Treffer innerhalb der durchsuchten Zeichenkette. Alle Eigenschaften sind schreibgeschützt:

• Value (String, nur Lesen): Der Text, der durch das Muster gefunden wurde. Value ist die Standardeigenschaft der Klasse.
• FirstIndex (Long, nur Lesen): Die Position des ersten Zeichens des Treffers innerhalb der durchsuchten Zeichenkette. Achtung: Der Index ist nullbasiert. Das erste Zeichen der Zeichenkette hat den Index 0. Dies unterscheidet sich von den meisten anderen VBA-Funktionen wie Mid oder InStr, die mit 1 beginnen.
• Length (Long, nur Lesen): Die Länge des gefundenen Treffers in Zeichen.
• SubMatches (SubMatches, nur Lesen): Eine Auflistung der durch einfangende Gruppen (Klammern im Muster) gefundenen Teilübereinstimmungen. Wenn das Muster keine Klammern enthält, ist die Auflistung leer.

Die Klasse SubMatches

Die Klasse SubMatches ist eine schreibgeschützte Auflistung von Zeichenketten.

Jeder Eintrag entspricht dem Text, der durch eine einfangende Gruppe im Suchmuster gefunden wurde.

• Count (Long, nur Lesen): Die Anzahl der Teilübereinstimmungen.
• Item(Index) (String, nur Lesen): Gibt die Teilübereinstimmung an der angegebenen Position zurück. Der Index beginnt bei 0. Beachte, dass SubMatches(0) nicht den gesamten Treffer enthält, sondern den Text der ersten einfangenden Gruppe. Dies unterscheidet sich von vielen anderen Programmiersprachen, in denen Index 0 den Gesamttreffer liefert.

Kurzübersicht: Muster-Syntax

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.

Zeichenklassen und Metazeichen:

• . (Punkt): Steht für ein beliebiges Zeichen außer dem Zeilenumbruch.
• \d: Eine Ziffer (entspricht [0-9]).
• \D: Ein Zeichen, das keine Ziffer ist.
• \w: Ein Wortzeichen (Buchstabe, Ziffer oder Unterstrich).
• \W: Ein Zeichen, das kein Wortzeichen ist.
• \s: Ein Whitespace-Zeichen (Leerzeichen, Tabulator, Zeilenumbruch).
• \S: Ein Zeichen, das kein Whitespace ist.
• [abc]: Eines der Zeichen a, b oder c.
• [^abc]: Kein Zeichen aus a, b oder c.
• [a-z]: Ein Zeichen im Bereich von a bis z.

Quantifizierer:

• *: Null oder mehr Wiederholungen.
• +: Eine oder mehr Wiederholungen.
• ?: Null oder eine Wiederholung.
• {n}: Genau n Wiederholungen.
• {n,}: Mindestens n Wiederholungen.
• {n,m}: Mindestens n, höchstens m Wiederholungen.

Anker und Gruppen:

• ^: Anfang der Zeichenkette (beziehungsweise der Zeile bei Multiline = True).
• $: Ende der Zeichenkette (beziehungsweise der Zeile bei Multiline = True).
• \b: Wortgrenze.
• (Ausdruck): Einfangende Gruppe. Der Treffer der Gruppe wird in SubMatches gespeichert.
• |: Alternation (“oder”).

Grundlegende Beispiele

Wir beginnen mit den grundlegenden Methoden der RegExp-Klasse. Alle Prozeduren verwenden Early Binding, das heißt, Du benötigst mindestens Office Version 2508.

Einfacher Test auf ein Muster

Die Methode Test gibt True zurück, sobald das Muster irgendwo in der Zeichenkette gefunden wird.

In diesem Fall sucht das Muster \d+ nach einer oder mehreren aufeinanderfolgenden Ziffern.

Public Sub TestAufMuster()
    Dim rx As RegExp
    Set rx = New RegExp
    rx.Pattern = "\d+"
    'Prüft, ob Ziffern enthalten sind
    Debug.Print rx.Test("Hallo 42")
    'Ausgabe: True
    Debug.Print rx.Test("Hallo Welt")
    'Ausgabe: False
End Sub

Alle Treffer mit Execute ermitteln

Beachte, dass Global auf True gesetzt werden muss, damit alle Treffer und nicht nur der erste ermittelt werden.

Die Eigenschaft FirstIndex ist nullbasiert, Position 5 entspricht also dem sechsten Zeichen:

Public Sub AlleTreffer()
    Dim rx As RegExp
    Dim colMatches As MatchCollection
    Dim objMatch As Match
    Set rx = New RegExp
    rx.Pattern = "\d+"
    rx.Global = True
    Set colMatches = rx.Execute("Art. 12, Art. 345")
    Debug.Print "Treffer: " & colMatches.Count
    'Ausgabe: Treffer: 2
    For Each objMatch In colMatches
        Debug.Print objMatch.Value & " an Position " _
            & objMatch.FirstIndex
    Next objMatch
    'Ausgabe:
    '12 an Position 5
    '345 an Position 14
End Sub

Einfaches Ersetzen mit Replace

Im folgenden Beispiel wollen wir alle Auftreten von Zahlenwerten durch XXX ersetzen. Dazu stellen wir als Pattern \d+ ein, was nach einer oder mehreren aufeinanderfolgenden Ziffern sucht. Diese werden durch die Replace-Methode jeweils durch XXX ersetzt:

Public Sub EinfachesErsetzen()
    Dim rx As RegExp
    Dim strResult As String
    Set rx = New RegExp
    rx.Pattern = "\d+"
    rx.Global = True
    strResult = rx.Replace("Art. 12, Art. 345", "XXX")
    Debug.Print strResult
    'Ausgabe: Art. XXX, Art. XXX
End Sub

SubMatches: Gruppen auswerten

Einfangende Gruppen in runden Klammern ermöglichen es, Teile eines Treffers gezielt auszulesen. Die gefundenen Teile stehen anschließend in der SubMatches-Auflistung des jeweiligen Match-Objekts zur Verfügung:

Public Sub GruppenAuswerten()
    Dim rx As RegExp
    Dim colMatches As MatchCollection
    Dim objMatch As Match
    Set rx = New RegExp
    'Datum im Format TT.MM.JJJJ
    rx.Pattern = "(\d{2})\.(\d{2})\.(\d{4})"
    rx.Global = True
    Set colMatches = rx.Execute("Beginn: 15.03.2025, " _
        & "Ende: 30.06.2025")
    For Each objMatch In colMatches
        Debug.Print "Gesamt: " & objMatch.Value
        Debug.Print "  Tag:   " & objMatch.SubMatches(0)
        Debug.Print "  Monat: " & objMatch.SubMatches(1)
        Debug.Print "  Jahr:  " & objMatch.SubMatches(2)
    Next objMatch
End Sub

Das Muster (\d{2})\.(\d{2})\.(\d{4}) enthält drei einfangende Gruppen für Tag, Monat und Jahr. Der Punkt muss mit \. maskiert werden, da er als Metazeichen sonst für ein beliebiges Zeichen stehen würde. Beachte, dass SubMatches(0) den Tag liefert, nicht den Gesamttreffer. Der Gesamttreffer steht in der Eigenschaft Value des Match-Objekts.

Ersetzen mit Rückverweisen

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:

Public Sub DatumUmformatieren()
    Dim rx As RegExp
    Dim strResult As String
    Set rx = New RegExp
    rx.Pattern = "(\d{2})\.(\d{2})\.(\d{4})"
    rx.Global = True
    'Deutsches in ISO-Format wandeln
    strResult = rx.Replace("15.03.2025", "$3-$2-$1")
    Debug.Print strResult
    'Ausgabe: 2025-03-15
End Sub

Hier wird das deutsche Datumsformat TT.MM.JJJJ in das ISO-Format JJJJ-MM-TT überführt, indem die Reihenfolge der Gruppen im Ersetzungstext vertauscht wird.

Validierung von Eingaben

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.

Public Function IstGueltigeEmail(strEmail As String) _
        As Boolean
    Dim rx As RegExp
    Set rx = New RegExp
    rx.IgnoreCase = True
    rx.Pattern = "^[\w.+-]+@" & "[\w-]+(\.[\w-]+)*" _
        & "\.[a-z]{2,}$"
    IstGueltigeEmail = rx.Test(strEmail)
End Function

Die Anker ^ und $ stellen sicher, dass die gesamte Zeichenkette dem Muster entsprechen muss und nicht nur ein Teil davon. Die Eigenschaft IgnoreCase sorgt dafür, dass sowohl groß- als auch kleingeschriebene Domainendungen akzeptiert werden. Du kannst die Funktion im Direktbereich testen:

'Im Direktbereich:
Debug.Print IstGueltigeEmail("test@example.com")
'Ausgabe: True
Debug.Print IstGueltigeEmail("ungueltig@@test")
'Ausgabe: False

Mehrere Muster auf einen Blick

Public Sub TestAufMuster()
    Dim rx As RegExp
    Set rx = New RegExp
    rx.Pattern = "\d+"
    'Prüft, ob Ziffern enthalten sind
    Debug.Print rx.Test("Hallo 42")
    'Ausgabe: True
    Debug.Print rx.Test("Hallo Welt")
    'Ausgabe: False
End Sub

Public Sub AlleTreffer()
    Dim rx As RegExp
    Dim colMatches As MatchCollection
    Dim objMatch As Match
    Set rx = New RegExp
    rx.Pattern = "\d+"
    rx.Global = True
    Set colMatches = rx.Execute("Art. 12, Art. 345")
    Debug.Print "Treffer: " & colMatches.Count
    'Ausgabe: Treffer: 2
    For Each objMatch In colMatches
        Debug.Print objMatch.Value & " an Position " _
            & objMatch.FirstIndex
    Next objMatch
    'Ausgabe:
    '12 an Position 5
    '345 an Position 14
End Sub

Public Sub EinfachesErsetzen()
    Dim rx As RegExp
    Dim strResult As String
    Set rx = New RegExp
    rx.Pattern = "\d+"
    rx.Global = True
    strResult = rx.Replace("Art. 12, Art. 345", "XXX")
    Debug.Print strResult
    'Ausgabe: Art. XXX, Art. XXX
End Sub

Public Sub GruppenAuswerten()
    Dim rx As RegExp
    Dim colMatches As MatchCollection
    Dim objMatch As Match
    Set rx = New RegExp
    'Datum im Format TT.MM.JJJJ
    rx.Pattern = "(\d{2})\.(\d{2})\.(\d{4})"
    rx.Global = True
    Set colMatches = rx.Execute("Beginn: 15.03.2025, " _
        & "Ende: 30.06.2025")
    For Each objMatch In colMatches
        Debug.Print "Gesamt: " & objMatch.Value
        Debug.Print "  Tag:   " & objMatch.SubMatches(0)
        Debug.Print "  Monat: " & objMatch.SubMatches(1)
        Debug.Print "  Jahr:  " & objMatch.SubMatches(2)
    Next objMatch
End Sub

Public Sub DatumUmformatieren()
    Dim rx As RegExp
    Dim strResult As String
    Set rx = New RegExp
    rx.Pattern = "(\d{2})\.(\d{2})\.(\d{4})"
    rx.Global = True
    'Deutsches in ISO-Format wandeln
    strResult = rx.Replace("15.03.2025", "$3-$2-$1")
    Debug.Print strResult
    'Ausgabe: 2025-03-15
End Sub

Public Function IstGueltigeEmail(strEmail As String) _
        As Boolean
    Dim rx As RegExp
    Set rx = New RegExp
    rx.IgnoreCase = True
    rx.Pattern = "^[\w.+-]+@" & "[\w-]+(\.[\w-]+)*" _
        & "\.[a-z]{2,}$"
    IstGueltigeEmail = rx.Test(strEmail)
End Function

'Im Direktbereich:
Debug.Print IstGueltigeEmail("test@example.com")
'Ausgabe: True
Debug.Print IstGueltigeEmail("ungueltig@@test")
'Ausgabe: False

Oder hast Du eine konkrete Frage zu Deiner eigenen Access-Anwendung?

Vielleicht stellt Deine Anwendung Dich vor eine Herausforderung, zu der Du bisher keine Lösung findest. Schlechte Performance, kein ausreichender Zugriffsschutz, Du bist unsicher über Dein Datenmodell oder Dein Code liefert unerklärliche Fehler?

In unserem kostenlosen Access-Audit schaut sich André Minhorst persönlich gemeinsam mit Dir Deine Lösung per Zoom an – und zeigt Dir, wo Datenmodell, VBA-Code, Ergonomie und Sicherheit Optimierungspotenzial bieten.