Kaum eine VBA-Prozedur kommt ohne Zeichenketten aus. Wir zerlegen Dateinamen, setzen SQL-Anweisungen zusammen, bereinigen Importdaten oder formatieren Ausgaben – und greifen dabei ständig zu Left<\/b>, Mid<\/b>, InStr<\/b> und Replace<\/b>. Trotzdem wurden diese Funktionen in unserer VBA-Reihe bisher nie vollständig vorgestellt. Das holen wir hier nach: zuerst eine kompakte Übersicht aller Stringfunktionen, dann praxisnahe Lösungen für typische Aufgaben – vom CSV-Parsing über Pattern-Matching bis zur sicheren Zusammensetzung von SQL-Strings. Die VBA-Grundlagen setzen wir voraus; hier geht es um Techniken, die aus fragilen Einzeilern robuste Lösungen machen.<\/b><\/p>\n
Alle Stringfunktionen auf einen Blick<\/h2>\n
VBA bietet rund 30 Funktionen und Operatoren für die Arbeit mit Zeichenketten. Die folgende Liste zeigt sie gruppiert nach Aufgabe. Die meisten existieren in zwei Varianten: ohne Dollarzeichen (Ergebnis Variant<\/b>) und mit Dollarzeichen (Ergebnis String<\/b>). Die $<\/b>-Variante ist schneller und wirft bei Null<\/b> einen Laufzeitfehler statt Null<\/b> stillschweigend weiterzureichen. Für produktiven Code empfehlen wir grundsätzlich die $<\/b>-Form.<\/p>\n
Teilstrings extrahieren<\/b> – mit den folgenden Funktionen holen wir Teilzeichenketten von links, recht und auch aus der Mitte: <\/b><\/p>\n Suchen<\/b> – Du suchst die Position einer bestimmten Zeichenkette von vorn oder hinten? Hier sind die geeigneten Funktionen:<\/p>\n Ersetzen<\/b> – auch das gelingt schnell mit einer VBA-Funktion:<\/p>\n Aufteilen und Zusammenfügen<\/b> – diese beiden Funktionen trennen Texte an bestimmten Zeichen und schieben sie in ein Array und umgekehrt:<\/p>\n Bereinigen<\/b> – Leerzeichen vorn, hinten oder an beiden Seiten entfernen gelingt mit diesen Funktionen:<\/p>\n Groß-\/Kleinschreibung<\/b> – wer bequem zwischen beiden umwandeln möchte, hat diese Möglichkeiten:<\/p>\n Vergleichen und Analysieren<\/b> – dazu können wir die folgenden Funktionen nutzen:<\/p>\n Länge und Zeichencodes<\/b> – kein Problem mit diesen Funktionen:<\/p>\n Erzeugen und Füllen<\/b> – zum Erzeugen von beliebig vielen Zeichen in einer Zeichenkette:<\/p>\n Formatieren<\/b> – nur eine Funktion, aber sehr vielseitig einsetzbar:<\/p>\n Konvertieren<\/b> – für die folgenden Spezialfälle:<\/p>\n Verkettung<\/b> – mit unterschiedlicher Verarbeitung von Null<\/b>:<\/p>\n Sonstiges:<\/b><\/p>\n Warum gibt es die meisten Funktionen doppelt – einmal als Left<\/b> und einmal als Left$<\/b>? Der Grund ist einfach: Die Variante ohne Dollarzeichen gibt einen Variant<\/b> zurück, die Variante mit Dollarzeichen einen String<\/b>.<\/p>\n Das klingt nach Erbsenzählerei, hat aber eine handfeste Folge – die $<\/b>-Variante ist schneller, weil keine Typumwandlung anfällt, und sie ist ehrlicher, weil sie bei einem Null<\/b>-Wert einen Fehler auslöst, statt ihn stillschweigend weiterzureichen.<\/p>\n Für Fortgeschrittene ergibt sich daraus eine klare Regel: Wenn die Eingabe garantiert kein Null<\/b> enthält (etwa bei String<\/b>-Variablen oder bereits geprüften Werten), nehmen wir Left$<\/b>, Mid$<\/b>, Trim$<\/b> und so weiter. Nur wenn wir bewusst mit Null<\/b> aus Datenbankfeldern arbeiten, greifen wir zur Variant<\/b>-Variante – und sichern uns vorher mit Nz<\/b> ab.<\/p>\n Importdaten sind voller leerer Felder, und in Access heisst leer nun einmal Null<\/b>. Das Verhalten ist tückisch: Len(Null)<\/b> liefert nicht 0<\/b>, sondern selbst Null<\/b>.<\/p>\n Eine Prüfung wie If Len(varText) > 0 Then<\/b> ist damit wirkungslos – der Vergleich ergibt Null<\/b>, und If<\/b> behandelt das wie False<\/b>. Noch gefährlicher: Der Verkettungsoperator &<\/b> wandelt Null<\/b> still in einen Leerstring um, während +<\/b> das gesamte Ergebnis zu Null<\/b> macht.<\/p>\n Die Lösung in Access ist die Funktion Nz<\/b>. Sie ersetzt Null<\/b> durch einen Vorgabewert. Für unsere Zwecke lautet die Standard-Absicherung:<\/p>\n Ab jetzt können wir gefahrlos mit den $<\/b>-Funktionen arbeiten. vbNullString ist gleichbedeutend mit einer leeren Zeichenkette, wir könnten also auch nutzen:<\/p>\n Die drei Klassiker schneiden Teilstücke aus einer Zeichenkette heraus. Left$(strText, 5)<\/b> liefert die ersten fünf Zeichen, Right$(strText, 5)<\/b> die letzten fünf und Mid$(strText, 3, 4)<\/b> vier Zeichen ab Position 3<\/b>. Zwei Details lohnen sich zu merken: Die Zählung beginnt bei 1<\/b>, und das dritte Argument von Mid<\/b> ist optional – lässt man es weg, bekommt man den gesamten Rest ab der Startposition.<\/p>\n Ein typischer Praxisfall: Aus einem Dateinamen wie Kunden_2026-07-15_Export.csv<\/b> wollen wir das Datum extrahieren. Dafür kombinieren wir InStrRev<\/b> mit Mid$<\/b>.<\/p>\n Die Funktion aus Listing 1 nutzt gleich mehrere Techniken auf einmal: Split<\/b> zerlegt den Basisnamen an den Unterstrichen, der Like<\/b>-Operator prüft jedes Stück auf das ISO-Datumsmuster, und Left$<\/b> sowie Mid$<\/b> schneiden Jahr, Monat und Tag heraus.<\/p>\n Listing 1: Datum aus einem Dateinamen extrahieren mit Split, Like und Mid$<\/span><\/b><\/p>\n InStr<\/b> liefert die Position, an der eine Zeichenfolge zum ersten Mal vorkommt, und 0<\/b>, wenn sie nicht vorkommt. Die Funktion kennt zwei Aufrufformen: Ohne Startposition heisst es InStr(strText, strSuche)<\/b>, mit Startposition dagegen InStr(lngStart, strText, strSuche)<\/b> – die Startposition rutscht also nach vorn und schiebt die anderen Argumente eine Stelle weiter.<\/p>\n Wer das Vergleichsargument (vbBinaryCompare<\/b> oder vbTextCompare<\/b>) angeben will, muss zwingend die lange Form benutzen.<\/p>\n InStrRev<\/b> sucht dieselbe Zeichenfolge von hinten. Für Dateipfade ist das genau richtig, denn dort interessiert uns immer der letzte Backslash. Allerdings dreht InStrRev<\/b> die Argumentreihenfolge wieder um – hier heisst es InStrRev(strText, strSuche)<\/b>:<\/p>\n Die Funktion sucht den letzten Backslash und gibt alles danach zurück. Kommt kein Backslash vor, ist der gesamte String bereits der Dateiname.<\/p>\n Replace<\/b> ersetzt alle Vorkommen eines Teilstrings durch einen anderen. Die vollständige Signatur lautet Replace(strText, strSuche, strErsatz, lngStart, lngAnzahl, lngVergleich)<\/b>.<\/p>\n Die letzten drei Argumente sind optional. Allerdings hat Replace<\/b> eine Eigenheit, die viele übersehen: Gibt man lngStart<\/b> an, liefert die Funktion nicht den vollständigen String zurück, sondern nur den Teil ab lngStart<\/b>. Das überrascht und ist selten gewünscht.<\/p>\n Ein klassischer Einsatz ist die Bereinigung von Sonderzeichen für SQL-Strings – einfache Anführungszeichen müssen verdoppelt werden, damit sie keinen Syntaxfehler auslösen:<\/p>\n So können wir gefahrlos schreiben: strSQL = “WHERE Nachname = ‘” & SQLSafe(strName) & “‘”<\/b><\/p>\n Split<\/b> zerlegt einen String an einem Trennzeichen und liefert ein nullbasiertes Variant<\/b>-Array. Join<\/b> macht das Gegenteil – es fügt die Elemente eines Arrays mit einem Trennzeichen wieder zusammen. Zusammen bilden sie ein mächtiges Paar für Daten-Transformationen:<\/p>\n Die Funktion aus zerlegt den String an Leerzeichen. Mehrfach-Leerzeichen erzeugen dabei leere Array-Elemente, die wir herausfiltern. Anschliessend fügt Join<\/b> die übrigen Teile mit genau einem Leerzeichen wieder zusammen.<\/p>\n Trim<\/b> entfernt Leerzeichen am Anfang und Ende. Allerdings ausschliesslich normale Leerzeichen (Code 32). Tabulatoren, Zeilenumbrüche und vor allem das geschützte Leerzeichen (Code 160<\/b>) bleiben stehen.<\/p>\n Letzteres landet immer dann in den Daten, wenn jemand Text aus einer Webseite kopiert hat. Optisch ist es von einem gewöhnlichen Leerzeichen nicht zu unterscheiden – ein Vergleich schlägt trotzdem fehl.<\/p>\n Wir brauchen also eine Funktion, die gründlicher aufräumt:<\/p>\n Der Like<\/b>-Operator ist VBAs eingebauter Pattern-Matcher. Er ist kein vollwertiger regulärer Ausdruck, deckt aber erstaunlich viele Prüfungen ab.<\/p>\n Die Platzhalter:<\/p>\n Ob Like<\/b> Gross- und Kleinschreibung unterscheidet, hängt von Option Compare<\/b> ab. In Access-Modulen gilt standardmässig Option Compare Database<\/b> – und damit keine Unterscheidung.<\/p>\n Wer binär vergleichen will, muss das Modul auf Option Compare Binary<\/b> umstellen.<\/p>\n Ein Praxisbeispiel: Wir prüfen, ob ein String eine gültige deutsche PLZ ist (fünf Ziffern):<\/p>\n Und wir schauen uns noch ein komplexeres Muster an. Hier wollen wir eine E-Mail-Adresse grob prüfen. Dabei untersuchen wir, ob mindestens ein Zeichen vor und nach dem @<\/b> und mindestens ein Punkt in der Domain vorkommt:<\/p>\n Der Gleichheitsoperator =<\/b> in VBA vergleicht Strings abhängig von Option Compare<\/b>. Das ist in Access-Modulen problematisch, weil dort Option Compare Database<\/b> gilt und damit Gross-\/Kleinschreibung ignoriert wird.<\/p>\n StrComp<\/b> bietet einen Ausweg: StrComp(strA, strB, vbBinaryCompare)<\/b> vergleicht immer zeichengenau, unabhängig von der Moduleinstellung.<\/p>\n Die Funktion liefert -1<\/b> (erster String kleiner), 0<\/b> (gleich) oder 1<\/b> (erster String grösser). Für eine einfache Gleichheitsprüfung schreiben wir:<\/p>\n Die Funktion Format$<\/b> formatiert Zahlen, Datumsangaben und Strings nach einer Formatmaske. Für Strings ist sie weniger bekannt, aber durchaus nützlich – etwa um Postleitzahlen auf fünf Stellen mit führenden Nullen aufzufüllen:<\/p>\n Die Maske “00000”<\/b> sorgt dafür, dass aus 1067<\/b> die PLZ 01067<\/b> wird. Das ist der Grund, warum PLZ-Felder in der Datenbank als Textfeld angelegt sein sollten – eine Zahl verliert die führende Null unwiderruflich.<\/p>\n Die Funktion Split<\/b> zerlegt einen String an einem Trennzeichen. Für einfache CSV-Daten reicht das. Sobald aber das Trennzeichen innerhalb von Anführungszeichen vorkommt – etwa ein Semikolon in einer Adresse – versagt Split<\/b>. Wir brauchen einen Parser, der Anführungszeichen respektiert.<\/p>\n Die Funktion aus Listing 2 geht zeichenweise durch die Zeile. Ein Anführungszeichen schaltet den blnInQuote<\/b>-Modus um – solange wir darin sind, wird das Trennzeichen als normales Zeichen behandelt.<\/p>\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
String, Variant und das Dollarzeichen<\/h2>\n
Was Null mit Texten anstellt<\/h2>\n
Dim <\/span>strSicher As String<\/span>\r\nstrSicher = Nz(rst!Feldname, vbNullString)<\/pre>\nstrSicher = Nz(rst!Feldname, \"\")<\/pre>\n
Zerlegen mit Left, Right und Mid<\/h2>\n
Public Function <\/span>DateiDatumExtrahieren(ByVal strDateiname As String<\/span>) As Variant<\/span>\r\n Dim <\/span>varTeile As Variant<\/span>\r\n Dim <\/span>lngIndex As Long<\/span>\r\n DateiDatumExtrahieren = Null\r\n varTeile = Split<\/span>(DateiOhnePfad(strDateiname), \"_\")\r\n For lngIndex = LBound<\/span>(varTeile) To UBound<\/span>(varTeile)\r\n If <\/span>varTeile(lngIndex) Like \"####-##-##\" Then<\/span>\r\n DateiDatumExtrahieren = DateSerial(CLng(Left$(varTeile(lngIndex), 4)), _\r\n CLng(Mid$(varTeile(lngIndex), 6, 2)), CLng(Mid$(varTeile(lngIndex), 9, 2)))\r\n Exit For<\/span>\r\n End If<\/span>\r\n Next<\/span> lngIndex\r\nEnd Function<\/span><\/pre>\nSuchen mit InStr und InStrRev<\/h2>\n
Public Function <\/span>DateiOhnePfad( _\r\n ByVal strPfad As String<\/span>) As String<\/span>\r\n Dim <\/span>lngPos As Long<\/span>\r\n lngPos = InStrRev<\/span>(strPfad, \"\\\")\r\n If <\/span>lngPos = 0 Then<\/span>\r\n DateiOhnePfad = strPfad\r\n Else<\/span>\r\n DateiOhnePfad = Mid$(strPfad, lngPos + 1)\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nErsetzen mit Replace<\/h2>\n
Public Function <\/span>SQLSafe(ByVal strWert As String<\/span>) As String<\/span>\r\n SQLSafe = Replace<\/span>(strWert, \"'\", \"''\")\r\nEnd Function<\/span><\/pre>\nAufteilen und Zusammenfügen mit Split und Join<\/h2>\n
Public Function <\/span>EinLeerzeichen(ByVal strText As String<\/span>) _\r\n As String<\/span>\r\n Dim <\/span>varTeile As Variant<\/span>\r\n Dim <\/span>lngI As Long<\/span>\r\n Dim <\/span>lngZiel As Long<\/span>\r\n varTeile = Split<\/span>(strText, \" \")\r\n lngZiel = -1\r\n For lngI = LBound<\/span>(varTeile) To UBound<\/span>(varTeile)\r\n If <\/span>Len<\/span>(varTeile(lngI)) > 0 Then<\/span>\r\n lngZiel = lngZiel + 1\r\n varTeile(lngZiel) = varTeile(lngI)\r\n End If<\/span>\r\n Next<\/span> lngI\r\n If <\/span>lngZiel < 0 Then<\/span>\r\n EinLeerzeichen = vbNullString\r\n Else<\/span>\r\n ReDim Preserve varTeile(lngZiel)\r\n EinLeerzeichen = Join(varTeile, \" \")\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nBereinigen mit Trim und Verwandten<\/h2>\n
Public Function <\/span>TrimPlus(ByVal strText As String<\/span>) As String<\/span>\r\n strText = Replace<\/span>(strText, Chr$(160), \" \")\r\n strText = Replace<\/span>(strText, vbTab, \" \")\r\n strText = Replace<\/span>(strText, vbCr<\/span>, \" \")\r\n strText = Replace<\/span>(strText, vbLf<\/span>, \" \")\r\n Do While<\/span> InStr<\/span>(strText, \" \") > 0\r\n strText = Replace<\/span>(strText, \" \", \" \")\r\n Loop<\/span>\r\n TrimPlus = Trim$(strText)\r\nEnd Function<\/span><\/pre>\nPattern-Matching mit dem Like-Operator<\/h2>\n
\n
Public Function <\/span>IstPLZ(ByVal strWert As String<\/span>) As Boolean<\/span>\r\n IstPLZ = (strWert Like \"#####\")\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>IstEmailGrob(ByVal strWert As String<\/span>) _\r\n As Boolean<\/span>\r\n IstEmailGrob = (strWert Like \"?*@?*.?*\")\r\nEnd Function<\/span><\/pre>\nPräzise Vergleiche mit StrComp<\/h2>\n
If <\/span>StrComp(strEingabe, \"Admin\", vbBinaryCompare) = 0 Then<\/span>\r\n ' Exakte Uebereinstimmung inkl. Gross\/Klein\r\nEnd If<\/span><\/pre>\nFormatieren mit Format$<\/h2>\n
Public Function <\/span>PLZFormatieren(ByVal varPLZ As Variant<\/span>) _\r\n As String<\/span>\r\n PLZFormatieren = Format$(Nz(varPLZ, \"\"), \"00000\")\r\nEnd Function<\/span><\/pre>\nPraxislösung: CSV-Zeilen robust parsen<\/h2>\n
Public Function <\/span>CSVSplit<\/span>(ByVal strZeile As String<\/span>, Optional<\/span> ByVal strTrenner As String<\/span> = \";\") As Variant<\/span>\r\n Dim <\/span>colFelder As <\/span>New<\/span> Collection\r\n Dim <\/span>lngPos As Long<\/span>\r\n Dim <\/span>lngLen As Long<\/span>\r\n Dim <\/span>strFeld As String<\/span>\r\n Dim <\/span>blnInQuote As Boolean<\/span>\r\n Dim <\/span>strZeichen As String<\/span>\r\n lngLen<\/span> = Len<\/span>(strZeile)\r\n strFeld = vbNullString\r\n blnInQuote = False<\/span>\r\n For lngPos = 1 To lngLen\r\n strZeichen = Mid$(strZeile, lngPos, 1)\r\n If <\/span>strZeichen = \"\"\"\" Then<\/span>\r\n blnInQuote = Not<\/span> blnInQuote\r\n