VBA Basics: Strings und Stringfunktionen

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, Mid, InStr und Replace. 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.

Alle Stringfunktionen auf einen Blick

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) und mit Dollarzeichen (Ergebnis String). Die $-Variante ist schneller und wirft bei Null einen Laufzeitfehler statt Null stillschweigend weiterzureichen. Für produktiven Code empfehlen wir grundsätzlich die $-Form.

Teilstrings extrahieren – mit den folgenden Funktionen holen wir Teilzeichenketten von links, recht und auch aus der Mitte:

• Left/Left$: liefert die ersten n Zeichen von links
• Right/Right$: liefert die letzten n Zeichen von rechts
• Mid/Mid$: liefert ab Position p optional n Zeichen; ohne n den gesamten Rest

Suchen – Du suchst die Position einer bestimmten Zeichenkette von vorn oder hinten? Hier sind die geeigneten Funktionen:

• InStr: Position des ersten Vorkommens eines Suchstrings (von links)
• InStrRev: Position des letzten Vorkommens (von rechts)

Ersetzen – auch das gelingt schnell mit einer VBA-Funktion:

• Replace: ersetzt alle (oder n) Vorkommen eines Teilstrings

Aufteilen und Zusammenfügen – diese beiden Funktionen trennen Texte an bestimmten Zeichen und schieben sie in ein Array und umgekehrt:

• Split: zerlegt einen String an einem Trennzeichen in ein Array
• Join: fügt ein Array mit einem Trennzeichen zu einem String zusammen

Bereinigen – Leerzeichen vorn, hinten oder an beiden Seiten entfernen gelingt mit diesen Funktionen:

• Trim/Trim$: entfernt Leerzeichen am Anfang und Ende
• LTrim/LTrim$: entfernt Leerzeichen nur am Anfang
• RTrim/RTrim$: entfernt Leerzeichen nur am Ende

Groß-/Kleinschreibung – wer bequem zwischen beiden umwandeln möchte, hat diese Möglichkeiten:

• UCase/UCase$: wandelt in Grossbuchstaben um
• LCase/LCase$: wandelt in Kleinbuchstaben um
• StrConv: vielseitig: Gross, Klein, Proper Case, Unicode-Konvertierung

Vergleichen und Analysieren – dazu können wir die folgenden Funktionen nutzen:

• StrComp: vergleicht zwei Strings mit wählbarer Methode (binär oder textuell); liefert -1, 0 oder 1
• Like: Operator für Pattern-Matching mit Platzhaltern (*, ?, #, […])

Länge und Zeichencodes – kein Problem mit diesen Funktionen:

• Len: Anzahl der Zeichen (bei Null: liefert Null)
• Asc: liefert den Zeichencode des ersten Zeichens
• Chr/Chr$: liefert das Zeichen zu einem Code

Erzeugen und Füllen – zum Erzeugen von beliebig vielen Zeichen in einer Zeichenkette:

• String/String$: wiederholt ein einzelnes Zeichen n-mal
• Space/Space$: erzeugt n Leerzeichen

Formatieren – nur eine Funktion, aber sehr vielseitig einsetzbar:

• Format/Format$: formatiert Zahlen, Datumsangaben und Strings nach einer Formatmaske

Konvertieren – für die folgenden Spezialfälle:

• CStr: wandelt einen beliebigen Wert in einen String um
• Val: liest eine Zahl vom Anfang eines Strings
• Str/Str$: wandelt eine Zahl in einen String (mit führendem Leerzeichen)

Verkettung – mit unterschiedlicher Verarbeitung von Null:

• &: Verkettungsoperator; wandelt Null in Leerstring um
• +: alternativer Operator; vererbt Null an das Ergebnis

Sonstiges:

• StrReverse: dreht die Zeichenfolge um
• Nz: Access-spezifisch; ersetzt Null durch einen Vorgabewert

String, Variant und das Dollarzeichen

Warum gibt es die meisten Funktionen doppelt – einmal als Left und einmal als Left$? Der Grund ist einfach: Die Variante ohne Dollarzeichen gibt einen Variant zurück, die Variante mit Dollarzeichen einen String.

Das klingt nach Erbsenzählerei, hat aber eine handfeste Folge – die $-Variante ist schneller, weil keine Typumwandlung anfällt, und sie ist ehrlicher, weil sie bei einem Null-Wert einen Fehler auslöst, statt ihn stillschweigend weiterzureichen.

Für Fortgeschrittene ergibt sich daraus eine klare Regel: Wenn die Eingabe garantiert kein Null enthält (etwa bei String-Variablen oder bereits geprüften Werten), nehmen wir Left$, Mid$, Trim$ und so weiter. Nur wenn wir bewusst mit Null aus Datenbankfeldern arbeiten, greifen wir zur Variant-Variante – und sichern uns vorher mit Nz ab.

Was Null mit Texten anstellt

Importdaten sind voller leerer Felder, und in Access heisst leer nun einmal Null. Das Verhalten ist tückisch: Len(Null) liefert nicht 0, sondern selbst Null.

Eine Prüfung wie If Len(varText) > 0 Then ist damit wirkungslos – der Vergleich ergibt Null, und If behandelt das wie False. Noch gefährlicher: Der Verkettungsoperator & wandelt Null still in einen Leerstring um, während + das gesamte Ergebnis zu Null macht.

Die Lösung in Access ist die Funktion Nz. Sie ersetzt Null durch einen Vorgabewert. Für unsere Zwecke lautet die Standard-Absicherung:

Dim strSicher As String
strSicher = Nz(rst!Feldname, vbNullString)

Ab jetzt können wir gefahrlos mit den $-Funktionen arbeiten. vbNullString ist gleichbedeutend mit einer leeren Zeichenkette, wir könnten also auch nutzen:

strSicher = Nz(rst!Feldname, "")

Zerlegen mit Left, Right und Mid

Die drei Klassiker schneiden Teilstücke aus einer Zeichenkette heraus. Left$(strText, 5) liefert die ersten fünf Zeichen, Right$(strText, 5) die letzten fünf und Mid$(strText, 3, 4) vier Zeichen ab Position 3. Zwei Details lohnen sich zu merken: Die Zählung beginnt bei 1, und das dritte Argument von Mid ist optional – lässt man es weg, bekommt man den gesamten Rest ab der Startposition.

Ein typischer Praxisfall: Aus einem Dateinamen wie Kunden_2026-07-15_Export.csv wollen wir das Datum extrahieren. Dafür kombinieren wir InStrRev mit Mid$.

Die Funktion aus Listing 1 nutzt gleich mehrere Techniken auf einmal: Split zerlegt den Basisnamen an den Unterstrichen, der Like-Operator prüft jedes Stück auf das ISO-Datumsmuster, und Left$ sowie Mid$ schneiden Jahr, Monat und Tag heraus.

Public Function DateiDatumExtrahieren(ByVal strDateiname As String) As Variant
    Dim varTeile As Variant
    Dim lngIndex As Long
    DateiDatumExtrahieren = Null
    varTeile = Split(DateiOhnePfad(strDateiname), "_")
    For lngIndex = LBound(varTeile) To UBound(varTeile)
        If varTeile(lngIndex) Like "####-##-##" Then
            DateiDatumExtrahieren = DateSerial(CLng(Left$(varTeile(lngIndex), 4)), _
                CLng(Mid$(varTeile(lngIndex), 6, 2)), CLng(Mid$(varTeile(lngIndex), 9, 2)))
            Exit For
        End If
    Next lngIndex
End Function

Listing 1: Datum aus einem Dateinamen extrahieren mit Split, Like und Mid$

Suchen mit InStr und InStrRev

InStr liefert die Position, an der eine Zeichenfolge zum ersten Mal vorkommt, und 0, wenn sie nicht vorkommt. Die Funktion kennt zwei Aufrufformen: Ohne Startposition heisst es InStr(strText, strSuche), mit Startposition dagegen InStr(lngStart, strText, strSuche) – die Startposition rutscht also nach vorn und schiebt die anderen Argumente eine Stelle weiter.

Wer das Vergleichsargument (vbBinaryCompare oder vbTextCompare) angeben will, muss zwingend die lange Form benutzen.

InStrRev sucht dieselbe Zeichenfolge von hinten. Für Dateipfade ist das genau richtig, denn dort interessiert uns immer der letzte Backslash. Allerdings dreht InStrRev die Argumentreihenfolge wieder um – hier heisst es InStrRev(strText, strSuche):

Public Function DateiOhnePfad( _
        ByVal strPfad As String) As String
    Dim lngPos As Long
    lngPos = InStrRev(strPfad, "\")
    If lngPos = 0 Then
        DateiOhnePfad = strPfad
    Else
        DateiOhnePfad = Mid$(strPfad, lngPos + 1)
    End If
End Function

Die Funktion sucht den letzten Backslash und gibt alles danach zurück. Kommt kein Backslash vor, ist der gesamte String bereits der Dateiname.

Ersetzen mit Replace

Replace ersetzt alle Vorkommen eines Teilstrings durch einen anderen. Die vollständige Signatur lautet Replace(strText, strSuche, strErsatz, lngStart, lngAnzahl, lngVergleich).

Die letzten drei Argumente sind optional. Allerdings hat Replace eine Eigenheit, die viele übersehen: Gibt man lngStart an, liefert die Funktion nicht den vollständigen String zurück, sondern nur den Teil ab lngStart. Das überrascht und ist selten gewünscht.

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:

Public Function SQLSafe(ByVal strWert As String) As String
    SQLSafe = Replace(strWert, "'", "''")
End Function

So können wir gefahrlos schreiben: strSQL = “WHERE Nachname = ‘” & SQLSafe(strName) & “‘”

Aufteilen und Zusammenfügen mit Split und Join

Split zerlegt einen String an einem Trennzeichen und liefert ein nullbasiertes Variant-Array. Join 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:

Public Function EinLeerzeichen(ByVal strText As String) _
        As String
    Dim varTeile As Variant
    Dim lngI As Long
    Dim lngZiel As Long
    varTeile = Split(strText, " ")
    lngZiel = -1
    For lngI = LBound(varTeile) To UBound(varTeile)
        If Len(varTeile(lngI)) > 0 Then
            lngZiel = lngZiel + 1
            varTeile(lngZiel) = varTeile(lngI)
        End If
    Next lngI
    If lngZiel < 0 Then
        EinLeerzeichen = vbNullString
    Else
        ReDim Preserve varTeile(lngZiel)
        EinLeerzeichen = Join(varTeile, " ")
    End If
End Function

Die Funktion aus zerlegt den String an Leerzeichen. Mehrfach-Leerzeichen erzeugen dabei leere Array-Elemente, die wir herausfiltern. Anschliessend fügt Join die übrigen Teile mit genau einem Leerzeichen wieder zusammen.