Reguläre Ausdrücke in VBA, Teil 1: Basics

Wer in VBA prüfen will, ob eine Eingabe eine gültige E-Mail-Adresse ist, baut sich meist eine Schleife mit „InStr“, „Mid“ und „Left“ zusammen – und kämpft dann mit Sonderfällen. Mit regulären Ausdrücken erledigt eine einzige Zeile dieselbe Aufgabe. Das nötige Werkzeug gehört seit vielen Jahren zu Windows, allerdings über eine Bibliothek, die Microsoft gerade abkündigt. Gleichzeitig hat das VBA-Team reagiert und die Funktionalität fest eingebaut. Dieser erste Teil unserer Reihe zeigt, wie Sie das Objekt einbinden, welche Klassen es mitbringt und wie die Mustersprache funktioniert. Der zweite Teil liefert dann fertige Rezepte für den Alltag.

Wozu das Ganze?

Ein regulärer Ausdruck ist ein Suchmuster, das mit einer eigenen kleinen Sprache beschreibt, wie ein gesuchter Text aufgebaut ist.

Statt Zeichen für Zeichen zu prüfen, formulieren wir also die Regel – und die Suchmaschine kümmert sich um den Rest. Ein paar Aufgaben, die sich damit auf eine Zeile eindampfen lassen:

• Prüfen, ob eine Eingabe dem Format einer E-Mail-Adresse entspricht
• Alle Zahlen aus einem Freitextfeld herauslösen
• HTML-Tags aus einem kopierten Text entfernen
• Platzhalter in einer Textvorlage durch Werte ersetzen
• Mehrfache Leerzeichen und Zeilenumbrüche zu einem einzigen zusammenfassen
• Prüfen, ob eine Telefonnummer nur erlaubte Zeichen enthält

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.

Das RegExp-Objekt einbinden

Bis vor Kurzem gab es genau einen Weg: das Objekt VBScript.RegExp aus der Bibliothek Microsoft VBScript Regular Expressions 5.5, die hinter der Datei vbscript.dll steckt. Sie binden es entweder über einen Verweis ein (frühe Bindung) oder erzeugen es zur Laufzeit über CreateObject (späte Bindung). Den Verweis finden Sie im VBA-Editor unter Extras/Verweise – Bild 1 zeigt den entsprechenden Eintrag.

Bild 1: Der Verweis auf die VBScript-Bibliothek im Verweise-Dialog

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.

Die gute Nachricht: Das VBA-Team hat vorgesorgt. Ab Office-Version 2508 (Build 19127.20154) sind die RegExp-Klassen fest in VBA eingebaut und stehen ohne jeden Verweis zur Verfügung. Sie können also einfach schreiben:

Dim objRegEx As RegExp
Set objRegEx = New RegExp

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:

Debug.Print TypeName(New RegExp)
RegExp

Alternativ werfen Sie einen Blick auf die Datei vbe7.dll 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.

Für Anwendungen, die Sie ausliefern, ergibt sich daraus eine klare Empfehlung: Verwenden Sie die späte Bindung. Der Aufruf mit CreateObject 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.

Dim objRegEx As Object
Set objRegEx = CreateObject("VBScript.RegExp")

Eine Entwarnung noch, weil die Frage regelmäßig aufkommt: Die Objekte Scripting.Dictionary und Scripting.FileSystemObject sind von der Abkündigung nicht betroffen. Sie stammen aus der Bibliothek scrrun.dll und bleiben erhalten – das hat der zuständige Produktmanager auf Nachfrage ausdrücklich bestätigt.

Vier Klassen, mehr braucht es nicht

Das Objektmodell ist erfreulich übersichtlich.

Es besteht aus genau vier Klassen:

• RegExp ist das Suchobjekt. Hier legen Sie das Muster und die Optionen fest und starten die Suche.
• MatchCollection nimmt alle gefundenen Treffer auf. Die Auflistung ist nullbasiert und kennt die Eigenschaft Count.
• Match steht für einen einzelnen Treffer mit den Eigenschaften Value, FirstIndex und Length.
• SubMatches enthält die Inhalte der Klammergruppen innerhalb eines Treffers – ebenfalls nullbasiert.

Bei der späten Bindung deklarieren Sie alle diese Variablen schlicht als Object. Sie verlieren dadurch zwar IntelliSense, gewinnen aber die Lauffähigkeit auf allen Systemen.

Die vier Eigenschaften des RegExp-Objekts

Bevor wir suchen, stellen wir das Objekt ein. Es gibt genau vier Eigenschaften, und drei davon sind Schalter:

• Pattern nimmt den regulären Ausdruck als Zeichenkette auf.
• Global bestimmt, ob nach dem ersten Treffer weitergesucht wird. Der Standardwert ist False – das ist die häufigste Stolperfalle überhaupt, denn ein Replace ersetzt dann nur das erste Vorkommen.
• IgnoreCase schaltet die Unterscheidung von Groß- und Kleinschreibung ab. Auch hier lautet der Standardwert False, Suchen erfolgen also zunächst groß-/kleinschreibungsempfindlich.
• Multiline sorgt dafür, dass die Anker für Zeilenanfang und Zeilenende nicht nur am Anfang und Ende des gesamten Textes greifen, sondern an jedem Zeilenumbruch.

Damit haben wir alles beisammen, um die erste Suche zu starten.

Die Methode Test: Passt das Muster?

Am einfachsten ist Test. Die Methode liefert schlicht True oder False zurück, je nachdem, ob das Muster irgendwo im übergebenen Text vorkommt.

Das folgende Listing prüft, ob eine Zeichenkette ausschließlich eine fünfstellige Postleitzahl enthält.

Public Sub TestPostleitzahl()
    Dim objRegEx As Object
    Set objRegEx = CreateObject("VBScript.RegExp")
    objRegEx.Pattern = "^\d{5}$"
    Debug.Print objRegEx.Test("47051")
    Debug.Print objRegEx.Test("4705")
    Debug.Print objRegEx.Test("47051 Duisburg")
End Sub

Die Ausgabe im Direktbereich sieht so aus:

Wahr
Falsch
Falsch

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.

Ohne diese beiden Zeichen würde auch die dritte Zeile ein Wahr 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 aus dem gewünschten Muster besteht, muss beide Anker setzen.

Die Methode Execute: Was wurde gefunden?

Interessanter wird es, wenn wir wissen wollen, was gefunden wurde. Dazu dient Execute. Die Methode liefert eine MatchCollection zurück, durch die wir schlicht mit For Each laufen. Listing 1 sucht alle Zahlen in einem Freitext.

Public Sub ZahlenFinden()
    Dim objRegEx As Object
    Dim objTreffer As Object
    Dim objMatch As Object
    Dim strText As String
    strText = "Bestellung 4711 vom 12.03.2026 über 3 Stueck zu je 19,90 Euro"
    Set objRegEx = CreateObject("VBScript.RegExp")
    objRegEx.Pattern = "\d+"
    objRegEx.Global = True
    Set objTreffer = objRegEx.Execute(strText)
    Debug.Print "Treffer: " & objTreffer.Count
    For Each objMatch In objTreffer
        Debug.Print objMatch.FirstIndex + 1, objMatch.Length, objMatch.Value
    Next objMatch
End Sub

Listing 1: Alle Zahlen eines Textes ermitteln

Der Direktbereich meldet:

Treffer: 7
12            4             4711
22            2             12
25            2             03
28            4             2026
39            1             3
50            2             19
53            2             90

Zwei Beobachtungen. Erstens war hier Global = True entscheidend – ohne diese Zeile hätten wir genau einen Treffer erhalten. Zweitens rechnen wir bei FirstIndex eine Eins hinzu.

Die Eigenschaft ist nämlich nullbasiert, während Mid und Left 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 gesagt, nicht Datum. Wie man das sauber formuliert, sehen wir gleich.

Klammergruppen und SubMatches

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. Damit zerlegen wir ein Datum in seine Bestandteile (siehe Listing 2).

Public Sub DatumZerlegen()
    Dim objRegEx As Object
    Dim objTreffer As Object
    Dim objMatch As Object
    Set objRegEx = CreateObject("VBScript.RegExp")
    objRegEx.Pattern = "(\d{1,2})\.(\d{1,2})\.(\d{4})"
    objRegEx.Global = True
    Set objTreffer = objRegEx.Execute( _
        "Termine: 12.03.2026 und 5.4.2026")
    For Each objMatch In objTreffer
        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

Listing 2: Zerlegen eines Datums in Tag, Monat und Jahr

Beachten Sie die maskierten Punkte im Muster. Ein unmaskierter Punkt bedeutet nämlich ein beliebiges Zeichen – wir wollen hier aber wirklich einen Punkt sehen. Der umgekehrte Schrägstrich davor nimmt dem Punkt seine Sonderbedeutung. Das Ergebnis:

Gesamt: 12.03.2026
  Tag:   12
  Monat: 03
  Jahr:  2026
Gesamt: 5.4.2026
  Tag:   5
  Monat: 4
  Jahr:  2026

Die Methode Replace

Die dritte Methode ersetzt gefundene Stellen durch einen neuen Text. Der Clou dabei: Im Ersatztext können Sie mit $1 bis $9 auf die Klammergruppen zugreifen und mit $& auf den gesamten Treffer. Damit lässt sich ein deutsches Datum in einem Rutsch in das ISO-Format überführen (siehe Listing 3).

Public Function DatumNachIso(ByVal strText As String) As String
    Dim objRegEx As Object
    Set objRegEx = CreateObject("VBScript.RegExp")
    objRegEx.Global = True
    objRegEx.Pattern = "\b(\d{2})\.(\d{2})\.(\d{4})\b"
    DatumNachIso = objRegEx.Replace(strText, "$3-$2-$1")
End Function

Listing 3: Datumsangaben in das ISO-Format umschreiben

Der Aufruf DatumNachIso(„Rechnung vom 12.03.2026“) liefert Rechnung vom 2026-03-12. 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.

Die Mustersprache im Überblick

Nun zur Sprache selbst. Sie besteht aus einer überschaubaren Zahl von Bausteinen.

Zunächst die Zeichenklassen, also Platzhalter für eine Gruppe von Zeichen:

• . steht für ein beliebiges Zeichen außer dem Zeilenumbruch.
• \d trifft eine Ziffer, \D alles außer einer Ziffer.
• \w trifft ein Wortzeichen, \W das Gegenteil.
• \s trifft ein Leerzeichen im weiteren Sinne, also auch Tabulator und Umbruch.
• [abc] trifft genau eines der aufgeführten Zeichen, [a-z] einen Bereich und [^abc] alles außer den genannten Zeichen.

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. Umlaute und das scharfe S gehören nicht dazu. Ein Muster wie ^\w+$ weist den Namen Müller also zurück. Wer deutsche Namen prüfen will, muss die Zeichen ausdrücklich mit aufnehmen:

objRegEx.Pattern = "^[A-Za-zÄÖÜäöüß\- ]+$"

Der Bindestrich ist mit einem umgekehrten Schrägstrich maskiert, damit er nicht als Bereichsangabe interpretiert wird.

Als Nächstes die Quantoren, die angeben, wie oft der vorangehende Baustein vorkommen darf:

• ? bedeutet höchstens einmal, also einmal oder gar nicht.
• Der Stern bedeutet beliebig oft, auch gar nicht.
• + bedeutet mindestens einmal.
• {3} bedeutet genau dreimal, {2,4} zwei- bis viermal und {2,} mindestens zweimal.

Dazu kommen die Anker und Gruppierungen:

• ^ markiert den Textanfang, $ das Textende.
• \b markiert eine Wortgrenze.
• (…) bildet eine Gruppe, deren Inhalt in SubMatches landet.
• (?:…) bildet eine Gruppe, ohne sich den Inhalt zu merken – das ist schneller und hält die Nummerierung der übrigen Gruppen übersichtlich.
• | trennt Alternativen, etwa (Herr|Frau).

Gierig oder genügsam?

Ein Punkt, der Anfänger zuverlässig zur Verzweiflung bringt: Quantoren arbeiten standardmäßig gierig, greifen sich also so viel Text wie irgend möglich.