VBA Regex in Excel — das RegExp-Objekt und warum Ihr Treffer leer zurückkommt

TL;DR — Es gibt kein Regex-Schlüsselwort in VBA. Sie erzeugen das VBScript-RegExp-Objekt, entweder spät gebunden mit CreateObject("VBScript.RegExp") oder früh gebunden über einen Verweis. Es tut nichts, bis Sie seine Eigenschaften setzen: .Pattern und die zwei, die auf den wenig hilfreichen Wert voreingestellt sind — .Global = False (nur der erste Treffer) und .IgnoreCase = False (Groß-/Kleinschreibung beachtend). Dann wählen Sie das richtige Verb: .Test liefert einen Boolean, .Replace liefert eine Zeichenkette (Rückverweise sind $1, nicht \1), und .Execute liefert eine Sammlung von Treffern, deren gefangene Gruppen in .SubMatches liegen — nicht in .Value.

Sub RegexBasics()
    Dim re As Object
    Set re = CreateObject("VBScript.RegExp")   ' spaete Bindung - kein Verweis noetig
    re.Pattern = "PO-(\d+)"                     ' eine Gruppe faengt die Ziffern
    re.Global = True                            ' ALLE Treffer finden, nicht nur den ersten
    re.IgnoreCase = True                        ' Gross-/Kleinschreibung egal

    Dim m As Object
    For Each m In re.Execute("po-17 and PO-9004")
        Debug.Print m.Value             ' PO-17    dann PO-9004  (der ganze Treffer)
        Debug.Print m.SubMatches(0)     ' 17       dann 9004     (die gefangene Gruppe)
    Next m
End Sub

Was Sie lernen

Das mentale Modell — Regex ist ein Objekt, das Sie erzeugen, kein Schlüsselwort
Späte Bindung vs. Hinzufügen des Verweises, und der Kompilierfehler, der folgt
Warum Global = False bedeutet, dass Sie immer nur den ersten Treffer bekommen
Was Test, Replace und Execute jeweils zurückgeben
Warum das Extrahieren eines Werts heißt, über Match.Value hinaus zu SubMatches zu greifen
Was der VBScript-Musterdialekt unterstützt und was nicht

Das mentale Modell: Regex ist ein Objekt, das Sie erzeugen, kein Schlüsselwort

Aus fast jeder anderen Sprache kommend erwarten Sie einen regex-Operator oder eine regex-Funktion. VBA hat keins von beidem. Was es hat, ist eine COM-Komponente — die Bibliothek VBScript Regular Expressions —, die Sie instanziieren, mit Eigenschaften verdrahten und dann aufrufen. Das mentale Modell ist also nicht „eine Funktion aufrufen", sondern „ein Objekt konfigurieren und ihm dann eine Frage stellen". Jeder Frust weiter unten heißt in Wahrheit „ich habe vergessen, eine Eigenschaft zu setzen, bevor ich gefragt habe."

Das sagt Ihnen auch, wann es sich lohnt, danach zu greifen. RegExp ist das Schwergewicht an der Spitze der Leiter, über dem Like-Operator und dem schlichten InStr. Sie zahlen einen Aufwand — es erzeugen, das Muster setzen, die Schalter umlegen — und bekommen dafür Wiederholungszahlen, Alternation und das eine, was die anderen nicht können: gefangene Stücke herausziehen.

Die Einrichtung: späte Bindung vs. ein Verweis

Zwei Wege, an das Objekt zu kommen, und die Wahl hat echte Folgen:

' Spaete Bindung - portabel, braucht keinen Verweis, loest zur Laufzeit auf
Dim re As Object
Set re = CreateObject("VBScript.RegExp")

' Fruehe Bindung - erst den Verweis hinzufuegen, dann kompiliert dies
' Extras -> Verweise -> "Microsoft VBScript Regular Expressions 5.5"
Dim re As New RegExp

Frühe Bindung gibt Ihnen IntelliSense und etwas schnellere Aufrufe, aber sie kompiliert nur, wenn der Verweis angehakt ist — und schicken Sie die Arbeitsmappe an jemanden, dem der Verweis fehlt, bekommt er einen Kompilierfehler Benutzerdefinierter Typ nicht definiert auf der Zeile As New RegExp, bevor eine einzige Anweisung läuft. Späte Bindung (As Object + CreateObject) hat nichts von dieser Zerbrechlichkeit: Sie löst zur Laufzeit auf und reist ohne Verweis. Für alles, was Sie verteilen, bevorzugen Sie späte Bindung — die Portabilität ist den Verlust von IntelliSense wert.

Falle 1: Global ist aus, Sie bekommen also nur den ersten Treffer

.Global ist standardmäßig False, und dieser eine Standard verursacht die zwei häufigsten Meldungen „Regex ist kaputt":

re.Pattern = "\d+"
re.Global = False                       ' der Standard
Debug.Print re.Replace("a1 b2 c3", "#") ' "a# b2 c3"  <- nur der ERSTE Lauf ersetzt
Debug.Print re.Execute("a1 b2 c3").Count ' 1          <- nur der ERSTE Treffer gefunden

re.Global = True
Debug.Print re.Replace("a1 b2 c3", "#") ' "a# b# c#"  <- jetzt alle
Debug.Print re.Execute("a1 b2 c3").Count ' 3

Hat ein Replace nur das erste Vorkommen angefasst, oder fand eine Suche einen Treffer, wo Sie drei sehen, ist das fast immer die Ursache. Setzen Sie .Global = True, wann immer Sie „überall" meinen. Sein Nachbar .IgnoreCase ist auf dieselbe Weise standardmäßig False, also ist ein Muster, das eindeutig Text anderer Schreibung treffen sollte und es nicht tut, meist eines mit fehlendem re.IgnoreCase = True.

Falle 2: Test, Replace und Execute geben drei verschiedene Dinge zurück

Das Objekt bietet drei Verben, und ihre Rückgabetypen zu verwechseln ist der zweite große Stolperer:

re.Test(s) liefert einen Boolean — trifft das Muster irgendwo? Nutzen Sie es als Validator, den regex-gestützten Vetter von Like.
re.Replace(s, replacement) liefert eine Zeichenkette — die Eingabe mit jedem Treffer (bei Global) ersetzt. Rückverweise im Ersatz nutzen ein Dollarzeichen: $1 ist die erste gefangene Gruppe. \1 zu schreiben fügt einen wörtlichen Backslash-Eins ein, ein häufiger Bug bei Leuten, die aus anderen Sprachen kommen.
re.Execute(s) liefert eine MatchCollection — eine Sammlung von Match-Objekten, über die Sie iterieren, um sie zu inspizieren oder zu extrahieren.

re.Pattern = "(\d{4})-(\d{2})"
Debug.Print re.Test("2026-09")                 ' True
Debug.Print re.Replace("2026-09", "$2/$1")     ' "09/2026"  - $1, $2 sind die Gruppen

Wählen Sie das Verb nach der Antwort, die Sie brauchen: ein Ja/Nein ist Test, eine transformierte Zeichenkette ist Replace, und alles, wo Sie den getroffenen Text oder seine Stücke wollen, ist Execute.

Falle 3: zum Extrahieren über Value hinaus zu SubMatches greifen

Das ist die Falle, die Leute im Kreis laufen lässt. Jeder Match aus .Execute hat einen .Value — den ganzen getroffenen Text — und eine .SubMatches-Sammlung mit den gefangenen Gruppen, den Teilen, die Sie in Klammern gesetzt haben:

re.Pattern = "Invoice #(\d+) dated (\d{4}-\d{2}-\d{2})"
re.Global = True
Dim m As Object
For Each m In re.Execute("Invoice #4471 dated 2026-09-04")
    Debug.Print m.Value          ' Invoice #4471 dated 2026-09-04   (der ganze Treffer)
    Debug.Print m.SubMatches(0)  ' 4471                              (erste Gruppe)
    Debug.Print m.SubMatches(1)  ' 2026-09-04                        (zweite Gruppe)
    Debug.Print m.FirstIndex     ' 0    (0-basierte Startposition in der Eingabe)
Next m

Wollen Sie die Zahl, wollen Sie m.SubMatches(0), nicht m.Value — .Value zu lesen und sich zu wundern, warum es noch den umgebenden Text enthält, ist der Extraktions-Bug Nummer eins. SubMatches ist nullbasiert, und eine Gruppe, die nicht am Treffer teilnahm, kommt als leere Zeichenkette zurück, sichern Sie also über re.Test(s) (oder die Sammlung .Count) ab, bevor Sie hineinindizieren.

Der VBScript-Dialekt: was die Mustersprache kann und was nicht

VBAs Regex ist der VBScript-Dialekt (RegExp 5.5), nicht PCRE, und die Lücken bringen jeden ins Stolpern, der Regex-Erfahrung anderswo hat. Er unterstützt das Alltagswerkzeug: \d \w \s und ihre Negationen, die Quantoren * + ? {n} {n,m}, Alternation a|b, Gruppen ( ), Zeichenklassen [ ] und Anker ^ $ (wobei .MultiLine entscheidet, ob diese die Zeile oder die ganze Zeichenkette meinen). Er unterstützt kein Lookbehind, keine benannten Fanggruppen und keine atomaren/possessiven Gruppen — Muster, die sich darauf stützen, kompilieren schlicht nicht so, wie Sie es erwarten.

Eine VBA-spezifische Erleichterung: weil der Backslash innerhalb von VBA-Zeichenkettenliteralen kein Escape-Zeichen ist, schreiben Sie Muster direkt — "\d{4}", nicht "\\d{4}". Kein doppeltes Maskieren, anders als in C#, Java oder JSON. Das einzige Doppeln, das Sie brauchen, ist für ein wörtliches Anführungszeichen, VBAs eigenes "".

Die Meinung: Regex ist die Zeremonie nur für echte Struktur wert

RegExp ist das mächtigste Textwerkzeug in VBA und das, nach dem am häufigsten zu früh gegriffen wird. Das Objekt zu erzeugen, das Muster zu setzen und an Global und IgnoreCase zu denken ist echte Zeremonie, und für eine feste Form oder ein schlichtes Ja/Nein ist es Zeremonie, die Sie nicht brauchen — Like ist eine lesbare Zeile und InStr ist schneller für „enthält dieses Literal".

Die Linie, die Sie ziehen, ist Struktur, die Sie auseinandernehmen müssen. Wenn das Muster variable Wiederholung, echte Alternation oder — das Entscheidende — eine Gruppe hat, die Sie herausziehen müssen, ist Regex das einzige Werkzeug im Kasten, das es kann, und es verdient seinen Platz: eine Bestellnummer aus einer Betreffzeile, die Teile eines chaotischen Zeitstempels, jede E-Mail in einem Textklumpen. Greifen Sie dort danach, bevorzugen Sie späte Bindung, damit es reist, setzen Sie Global und IgnoreCase bewusst, und lesen Sie SubMatches für die Stücke. Alles darunter: klettern Sie die Leiter wieder hinab.

Wenn das Zerlegen der Punkt ist — beschreiben Sie die Aufgabe stattdessen

Selbst wenn Regex das richtige Werkzeug ist, ist das Muster selten das Ziel — „zieh jede Rechnungsnummer und ihr Datum aus dieser Spalte und teile sie in zwei Felder" ist es. Und ein VBScript-Muster mit Fanggruppen, plus die Schleife über Execute, plus die SubMatches-Buchhaltung, plus die Randfälle, in denen eine Zeile gar nicht trifft, ist eine Menge zerbrechlicher Maschinerie um eine Absicht. ExcelMaster lässt Sie das Ergebnis in normaler Sprache beschreiben — „extrahiere Rechnungsnummer und Datum aus Spalte B in die Spalten C und D, markiere Zeilen ohne Treffer" — und erzeugt Python, das die Extraktion mit einer echten Regex-Engine erledigt, zuerst Ihre Datei sichert und die Zeilen meldet, die es nicht zerlegen konnte. Sie beschreiben, was herauszuziehen ist; es kümmert sich um das Muster, die Gruppen und die Fehlschläge.

Häufig gestellte Fragen

Wie nutze ich Regex in VBA?

Erzeugen Sie das VBScript-RegExp-Objekt, setzen Sie seine Eigenschaften, dann rufen Sie eine Methode auf. Der portable Weg ist späte Bindung: Set re = CreateObject("VBScript.RegExp"), dann re.Pattern = "\d+", re.Global = True, re.IgnoreCase = True und schließlich re.Test(s), re.Replace(s, repl) oder re.Execute(s), je nachdem, ob Sie einen Boolean, eine neue Zeichenkette oder die Treffer wollen.

Warum ersetzt mein VBA-Regex nur den ersten Treffer?

Weil .Global standardmäßig False ist. Mit ausgeschaltetem Global halten sowohl .Replace als auch .Execute nach dem ersten Treffer an. Setzen Sie re.Global = True, bevor Sie sie aufrufen, um auf jeden Treffer in der Zeichenkette zu wirken.

Wie extrahiere ich in VBA-Regex eine gefangene Gruppe?

Iterieren Sie über re.Execute(s) und lesen Sie Match.SubMatches. SubMatches(0) ist die erste geklammerte Gruppe, SubMatches(1) die zweite und so weiter (nullbasiert). Match.Value ist der ganze getroffene Text, nicht die Gruppe — .Value zu lesen, wenn Sie eine Gruppe wollten, ist der häufigste Extraktionsfehler.

Muss ich einen Verweis hinzufügen, um Regex in VBA zu nutzen?

Nur für frühe Bindung. Dim re As New RegExp verlangt den Verweis „Microsoft VBScript Regular Expressions 5.5" unter Extras -> Verweise und kompiliert nicht, mit Benutzerdefinierter Typ nicht definiert, wenn er fehlt. Späte Bindung — Dim re As Object mit CreateObject("VBScript.RegExp") — braucht keinen Verweis und ist die bessere Wahl für Arbeitsmappen, die Sie teilen.

Welchen Regex-Dialekt nutzt VBA, und unterstützt er Lookbehind?

VBA nutzt den VBScript-Dialekt (RegExp 5.5). Er unterstützt \d \w \s, Quantoren, Alternation, Gruppen, Zeichenklassen und ^ $-Anker sowie Ersatz-Rückverweise mit $1. Er unterstützt kein Lookbehind und keine benannten Fanggruppen. Und weil der Backslash innerhalb von VBA-Zeichenkettenliteralen nicht besonders ist, schreiben Sie "\d{4}" direkt, ohne doppeltes Maskieren.

Getestet in

Getestet in: Excel 365 (Windows 11), VBA 7.1 — zuletzt geprüft am 04.09.2026.

Verwandte Anleitungen: VBA Like · VBA IsNumeric · VBA InStr · VBA Replace · VBA Split