Zeichenfolgenfunktionen

Einführung

Die VBA Zeichenfolgenfunktionen kommen etwas unscheinbar daher und werden meist unterschätzt. Eine Zeichenfolge (engl. String) ist nichts anderes als ein Stück Text. Zeichfolgen können Buchstaben, Zahlen oder Sonderzeichen in beliebiger Kombination enthalten. Die Verwendung von Zeichenfolgen ist ein sehr wichtiger Teil von VBA. Zeichenfolgen können auf viele Arten manipuliert werden. Dazu gehören beispielsweise

Extrahieren eines Teils einer Zeichenfolge
Zeichenfolgen vergleichen
Zahlen in eine Zeichenfolge umwandeln
Formatieren von Zahlen oder eines Datums mit Wochentag
Suchen eines Zeichens in einer Zeichenfolge
Leerzeichen entfernen

VBA enthäft viele Funktionen für die Durchführung derartiger Aufgaben.

Zeichenfolgenfunktionen in VBA

Umschalten zwischen Klein- und Großbuchstaben

Die UCase Funktion

Mit der Funktion UCase kann eine Zeichenfolge, die aus Groß- und Kleinbuchstaben besteht, in Großbuchstaben umgewandelt werden. Die Syntax ist
UCase(Zeichenfolge)

Die LCase Funktion

Die Funktion LCase dient dazu, eine Zeichenfolge, die aus Groß- und Kleinbuchstaben besteht, in Kleinbuchstaben umzuwandeln. Die Syntax ist
LCase(Zeichenfolge)

Sub Test_UCase_LCase()
Dim strText As String
strText = "Das ist ein Test"
Debug.Print strText
Debug.Print UCase(strText)
Debug.Print LCase(strText)
End Sub

Eine Teilzeichenfolge extrahieren

Funktion Left

Die Funktion Left gibt die gewünschte Anzahl von Zeichen von Links einer Zeichenfolge zurück.Die Syntax ist
Left(Zeichenfolge, n)
Dabei ist n die Anzahl an Zeichen, die von links her gezählt zurückgegeben werden sollen.

Sub Test_Left()
Dim strText As String, strErgebnis As String
strText = "Das ist ein Test."
strErgebnis = Left(strText, 7)
Debug.Print strErgebnis
'Der zurückgegebene String lautet: "Das ist"
End Sub

Funktion Right

Die Funktion Right gibt die gewünschte Anzahl von Zeichen von Rechts einer Zeichenfolge zurück. Die Syntax ist
Right(Zeichenfolge, n)
Dabei ist n die Anzahl an Zeichen, die von rechts her gezählt zurückgegeben werden sollen

Sub Test_Right()
Dim strText As String, strErgebnis As String
strText = "Das ist ein Test."
strErgebnis = Right(strText, 5)
Debug.Print strErgebnis
'Der zurückgegebene String lautet: "Test."
End Sub

Teile einer Zeichenfolge mit der Funktion Mid zurückgeben

Mit der Funktion Mid kann ein Teil einer Zeichenfolge zurückgegeben werden. Die Syntax ist
Mid(String, Start, [Länge])
Der Parameter Start ist die Position des Zeichens, ab der die Zeichenfolge zurückgegeben wird. Der optionale Parameter Länge (Length) ist die Anzahl an Zeichen ab der Position Start. Wenn der Parameter Länge nicht angegeben wird oder weniger Zeichen als Länge im Text vorhanden sind, werden alle Zeichen von der Position Start bis zum Ende der Zeichenfolge zurückgegeben.

Sub Test_Mid()
Dim strText As String, strErgebnis As String
strText = "Das ist ein Test."
strErgebnis = Mid(strText, 5, 3)
Debug.Print strErgebnis
'Der zurückgegebene String lautet: "ist"
End Sub

Die Split Funktion

Die Split Funktion teilt eine Zeichenfolge basierend auf einem Trennzeichen in Teilzeichenfolgen auf. Das Ergebnis wird als Array von Teilzeichenfolgen zurückgegeben. Die Syntax ist
Split ( Zeichenfolge [, Trennzeichen] [, limit] [, compare] )
wobei

Zeichenfolge – Zeichenfolge, die basierend auf einem Trennzeichen in Teilzeichenfolgen aufgeteilt werden soll.
Trennzeichen – Optional. Das Trennzeichen, das verwendet wird, um den Ausdruck in Teilzeichenfolgen aufzuteilen. Wenn nicht angegeben, ist das Trennzeichen standardmäßig ein Leerzeichen.
Limit – Optional. Die maximale Anzahl von Teilzeichenfolgen, die getrennt werden. Wenn nicht angegeben, wird das Limit standardmäßig auf -1 gesetzt, wodurch alle Teilzeichenfolgen aufgeteilt werden.
Der optionale Parameter Compare gibt die Art des Zeichenfolgenvergleichs an. Wenn leer, wird ein binärer Vergleich verwendet.
vbBinaryCompare – Führt einen binären Vergleich aus (Groß- und Kleinschreibung werden als unterschiedlich betrachtet).
vbTextCompare – Führt einen Textvergleich aus (Groß- und Kleinschreibung werden als gleich angesehen).
vbDatabaseCompare – Datenbankvergleich (nur für Microsoft Access).

Rückgabewert
Variant – Nullbasiertes Array von Teilzeichenfolgen.

Sub Test_Split()
Dim strText As String, varErgebnis As Variant, i As Integer
strText = "Das ist ein Test."
varErgebnis = Split(strText, " ")
Debug.Print "{";
For i = 0 To UBound(varErgebnis)
    If i < UBound(varErgebnis) Then
       Debug.Print varErgebnis(i) & ", ";
      Else
       Debug.Print varErgebnis(i) & "}"
    End If
Next i
End Sub

Die Position einer Teilzeichenfolge ermitteln

Die InStr Funktion

Mit der Funtion InStr kann die Position einer Suchzeichenfolge innerhalb einer Zeichenfolge vom Anfang an gezählt zurückgegeben werden. Die Syntax ist
InStr([Start], Zeichenfolge, Suchzeichenfolge, [ Compare ])

Der optionale Parameter Start legt die Anfangsposition für die Suche fest.Wenn nicht angegeben, beginnt die Suche beim ersten Zeichen.
Der Parameter Zeichenfolge ist die Zeichenfolge, die durchsucht wird.
Der Parameter Suchzeichenfolge ist die Zeichenfolge, nach der gesucht wird.
Der optionale Parameter Compare gibt die Art des Zeichenfolgenvergleichs an. Wenn leer, wird ein binärer Vergleich verwendet.
vbBinaryCompare – Führt einen binären Vergleich aus (Groß- und Kleinschreibung werden als unterschiedlich betrachtet).
vbTextCompare – Führt einen Textvergleich aus (Groß- und Kleinschreibung werden als gleich angesehen).
vbDatabaseCompare – Datenbankvergleich (nur für Microsoft Access).

Rückgabewert
Gibt die Position, gezählt vom Beginn der Zeichenfolge, des ersten Auftretens der Suchzeichenfolge innerhalb der Zeichenfolge zurück.

Anmerkungen:

Die Funktion InStr kann zur Suche nach der Suchzeichenfolge in einer Zeichenfolge verwendet werden.
Die inStr unterstützt die Verwendung der folgenden Wildcards:
1. Sternchen (*): Stellt ein oder mehrere Zeichen einer Zeichenfolge dar und funktioniert wie folgt:
„a*“ bezieht sich auf den Text, der mit dem Zeichen „a“ beginnt.
„*a“ bezieht sich auf den Text, der mit dem Zeichen „a“ endet.
„*a*“ bezieht sich auf den Text, der das Zeichen „a“ in der Mitte hat.
2. Fragezeichen (?): Es stellt ein Zeichen einer Zeichenfolge dar und funktioniert wie folgt:
„a?“ bezieht sich auf zwei Zeichen, die mit „a“ beginnen.
„?a“ bezieht sich auf zwei Zeichen, die auf „a“ enden.
„?a?“ bezieht sich auf drei Zeichen mit einem „a“ in der Mitte.
3. Tilde (~)
Immer wenn Sternchen oder Fragezeichen kein Platzhalter sein sollen, wird eine Tilde direkt davor gesetzt.

Sub Test_InStr()
Dim strText As String, intPosition As String
strText = "Das ist ein Test."
intPosition = InStr(1, strText, "ist")
Debug.Print intPosition
'Die zurückgegebene Position ist: 5
End Sub

Beispiel für die Suche nach einer Suchzeichenfolge:

Sub Suche_Suchzeichenfolge_in_Zeichenfolge()
Dim n As Long
'
n = InStr(1, "Das ist ein Test.", "ist")
If n = 0 Then
   Debug.Print "Suchzeichenfolge nicht gefunden."
Else
   Debug.Print "Suchzeichenfolge in Position: " & n & " gefunden."
End If
'
n = InStr(1, "Das ist ein Test.", "Text")
If n = 0 Then
   Debug.Print "Suchzeichenfolge nicht gefunden."
Else
   Debug.Print "Suchzeichenfolge in Position: " & n & " gefunden."
End If
End Sub

Die InStrRev Funktion

Die VBA-InStrRev-Funktion gibt die Startposition einer Teilzeichenfolge innerhalb einer anderen Zeichenfolge zurück, beginnt jedoch mit dem Zählen der Position am Ende der Zeichenfolge. Die Syntax ist
InStrRev(Zeichenfolge, Suchzeichenfolge, [Start], [Compare])

Der optionale Parameter Start legt die Anfangsposition für die Suche fest.Wenn nicht angegeben, beginnt die Suche beim ersten Zeichen.
Der Parameter Zeichenfolge ist die Zeichenfolge, die durchsucht wird.
Der Parameter Suchzeichenfolge ist die Zeichenfolge, nach der gesucht wird.
Der optionale Parameter Compare gibt die Art des Zeichenfolgenvergleichs an. Wenn leer, wird ein binärer Vergleich verwendet.
vbBinaryCompare – Führt einen binären Vergleich aus (Groß- und Kleinschreibung werden als unterschiedlich betrachtet).
vbTextCompare – Führt einen Textvergleich aus (Groß- und Kleinschreibung werden als gleich angesehen).
vbDatabaseCompare – Datenbankvergleich (nur für Microsoft Access).

Rückgabewert

Gibt die Position, vom Ende der Zeichenfolge gezählt, der Suchzeichenfolge innerhalb der Zeichenfolge von rechts nach links gesehen zurück.

Sub Test_InstrRev()
Dim strText As String, intPosition As String
strText = "Das ist ein Test."
intPosition = InStrRev(strText, "ein")
Debug.Print intPosition
'Die zurückgegebene Position ist: 9 (von Ende gezählt)
End Sub

Leerzeichen aus einer Zeichenfolge entfernen

Die LTrim Funktion

Die LTrim-Funktion entfernt alle führenden Leerzeichen aus einer Zeichenfolge. Die Syntax ist
LTrim(Zeichenfolge)

Sub Test_LTrim()
Dim strText1 As String, strText2 As String
strText1 = "         Das ist ein Test."
strText2 = LTrim(strText1)
Debug.Print strText1
Debug.Print strText2
End Sub

Die RTrim Funktion

Die RTrim-Funktion entfernt alle Leerzeichen am Ende einer Zeichenfolge. Die Syntax ist
RTrim(Zeichenfolge)

Sub Test_RTrim()
Dim strText1 As String, strText2 As String
strText1 = "Das ist ein Test.     "
strText2 = RTrim(strText1)
Debug.Print strText1; "<- Ende der Zeichenfolge"
Debug.Print strText2; "<- Ende der Zeichenfolge"
End Sub

Die Trim Funktion

Die Trim-Funktion entfernt alle Leerzeichen am Anfang und am Ende einer Zeichenfolge. Die Syntax ist
Trim(Zeichenfolge)

Sub Test_Trim()
Dim strText1 As String, strText2 As String
strText1 = "         Das ist ein Test.     "
strText2 = Trim(strText1)
Debug.Print strText1; "<- Ende der Zeichenfolge"
Debug.Print strText2; "<- Ende der Zeichenfolge"
End Sub

Die StrConv Funktion

Konvertiert Buchstaben in einer Zeichenfolge je nach angegebenem Konvertierungstyp in Großbuchstaben, Kleinbuchstaben, korrekte Groß- und Kleinschreibung oder Unicode. Die Syntax ist
StrConv(Zeichenfolge, Konvertierung, [LCID])
wobei

Zeichenfolge – Der ursprüngliche Text.
Konvertierung – Die gewünschte Konvertierungsart.
[LCID] (Optional) – Ein optionaler Parameter, der die LocaleID angibt. Wenn leer, wird die LocaleID des Systems verwendet.

Werte für den Parameter Konvertierung

Sub Test_StrConv()
Dim strText1 As String, strText2 As String
Dim i As Long, x() As Byte
  '
strText1 = "das ist ein test."
strText2 = StrConv(strText1, vbUpperCase)
Debug.Print strText1
Debug.Print strText2
Debug.Print
'
strText1 = "DAS IST EIN TEST."
strText2 = StrConv(strText1, vbLowerCase)
Debug.Print strText1
Debug.Print strText2
Debug.Print
'
strText1 = "DAS IST EIN TEST."
strText2 = StrConv(strText1, vbProperCase)
Debug.Print strText1
Debug.Print strText2
'
x = StrConv("Das ist ein Test.", vbFromUnicode)
For i = 0 To UBound(x)
    Debug.Print i, x(i)
Next
End Sub

Die Len Funktion

Gibt die Anzahl der Zeichen in einer Zeichenfolge zurück. Die Syntax ist
Len(Zeichenfolge)

Sub Test_Len()
Dim strText As String
strText = "Das ist ein Test."
Debug.Print Len(strText)
'Die zurückgegebene Länge ist: 17
End Sub

Die Replace Funktion

Die Replace Funktion ersetzt die Suchzeichenfolge in einer Zeichenfolge durch die Ersatzzeichenfolge. Die Syntax ist
Replace ( Zeichenfolge, Suchzeichenfolge, Ersatzzeichenfolge, [start, [count, [compare]]] )
wobei

Zeichenfolge – Ein Zeichenfolgenausdruck mit der zu ersetzenden Teilzeichenfolge.
Suchzeichenfolge – Teilzeichenfolge, nach der gesucht wird.
Ersatzzeichenfolge – Ersetzt die Suchzeichenfolge in der der Zeichenfolge.
start – Optional. Position in Zeichenfolge, an der die Suche beginnt. Wenn dieser Parameter weggelassen wird, beginnt die Suche an Position 1.
count – Optional. Anzahl der auszuführenden Ersetzungen. Wenn dieser Parameter weggelassen wird, werden alle Vorkommen der Suchzeichenfolge durch die Ersatzzeichenfolge ersetzt.
compare – Optional. Numerische Wert, der die Art des Vergleichs beim Auswerten von Teilzeichenfolgen angibt. Wenn leer, wird ein binärer Vergleich verwendet.
vbBinaryCompare – Führt einen binären Vergleich aus (Groß- und Kleinschreibung werden als unterschiedlich betrachtet).
vbTextCompare – Führt einen Textvergleich aus (Groß- und Kleinschreibung werden als gleich angesehen).
vbDatabaseCompare – Datenbankvergleich (nur für Microsoft Access).

Sub Test_Replace()
Dim strText1 As String, strText2 As String
'
strText1 = "Das ist ein Test."
'Zeichen ersetzen:
strText2 = Replace(strText1, "Test", "Text")
Debug.Print "Originaltext: "; strText1
Debug.Print "Geänderter Text: "; strText2
Debug.Print
'
strText1 = "Das ist ein Test."
'Zeichen ersetzen: Erst ab dem 4ten Zeichen beginnen
strText2 = Replace(strText1, "Test", "Text", Start:=4)
Debug.Print "Originaltext: "; strText1
Debug.Print "Geänderter Text: "; strText2
Debug.Print
'
strText1 = "Das ist ein Test Test Test Test."
'Zeichen ersetzen: mit Count
strText2 = Replace(strText1, "Test", "Text", Count:=2)
Debug.Print "Originaltext: "; strText1
Debug.Print "Geänderter Text: "; strText2
Debug.Print
'
strText1 = "Das ist ein Test Test Test Test."
'Zeichen ersetzen: mit Count
strText2 = Replace(strText1, "Test", "Text")
Debug.Print "Originaltext: "; strText1
Debug.Print "Geänderter Text: "; strText2
End Sub

Eine Zeichenfolge umkehren

Gibt die Zeichenfolge in umgekehrter Reihenfolge zurück. Die Syntax ist
StrReverse(Zeichenfolge)

Sub Test_StrReverse()
Dim strText1 As String, strText2 As String
'
strText1 = "Test"
strText2 = StrReverse(strText1) ' liefert xilebO
Debug.Print "Originaltext: "; strText1
Debug.Print "Geänderter Text: "; strText2
Debug.Print
'
' Palindrom
strText1 = "Neffen"
strText2 = StrReverse(strText1) ' liefert neffeN
Debug.Print "Palindrom"
Debug.Print "Originaltext: "; strText1
Debug.Print "Geänderter Text: "; strText2
End Sub

Zeichenfolgen vergleichen

Die Funktion StrComp

Wird verwendet, um zwei Zeichenfolgen zu vergleichen. Die Syntax ist
StrComp(Zeichenfolge1, Zeichenfolge2, [Compare])
wobei:

Zeichenfolge1 – Die erste der zu vergleichenden Zeichenfolgen
Zeichenfolge2 – Die zweite der zu vergleichenden Zeichenfolgen
Compare – Optional. Numerische Wert, der die Art des Vergleichs beim Auswerten von Teilzeichenfolgen angibt. Wenn leer, wird ein binärer Vergleich verwendet.
vbBinaryCompare – Führt einen binären Vergleich aus (Groß- und Kleinschreibung werden als unterschiedlich betrachtet).
vbTextCompare – Führt einen Textvergleich aus (Groß- und Kleinschreibung werden als gleich angesehen).
vbDatabaseCompare – Datenbankvergleich (nur für Microsoft Access).

Rückgabewert:
0 – die Zeichenfolgen stimmen überein
-1 – Zeichenfolge1 kleiner als Zeichenfolge2
1 – Zeichenfolge1 größer als Zeichefolge2
Null – eine der Zeichenfolgen den Wert „Null“ hat

Sub Test_StrComp()
Debug.Print StrComp("Test", "Test", vbTextCompare)   ' Ergebnis: 0
Debug.Print StrComp("Test 2", "Test", vbTextCompare) ' Ergebnis: 1
Debug.Print StrComp("Test", "Test 2", vbTextCompare) ' Ergebnis: -1
Debug.Print StrComp(Null, "Test", vbTextCompare)     ' Ergebnis: Null
End Sub

Zeichenfolgen mit Operatoren vergleichen

Zeichenfolgen können auch mit Operatoren verglichen werden. Das Ergebnis des Vergleichs ist entweder „Wahr“ (engl True), „Falsch“ (engl. False) oder Null, falls eine der beiden Zeichenketten den Wert „Null“ hat.

Sub Test_StrComp_Operator()
'
Debug.Print "'Test' = 'Test', Ergebnis: "; "Test" = "Test"       ' Ergebnis: Wahr (engl. True)
Debug.Print "'Test' <> 'Test', Ergebnis: "; "Test" <> "Test"     ' Ergebnis: Falsch (engl. False)
Debug.Print "'Test' > 'Test', Ergebnis: "; "Test" > "Test"       ' Ergebnis: Falsch (engl. False)
Debug.Print "'Test' >= 'Test', Ergebnis: "; "Test" >= "Test"     ' Ergebnis: Wahr (engl. True)
Debug.Print "'Test' < 'Test', Ergebnis: "; "Test" < "Test"       ' Ergebnis: Falsch (engl. False)
Debug.Print "'Test' <= 'Test', Ergebnis: "; "Test" <= "Test"     ' Ergebnis: Wahr (engl. True)
Debug.Print
'
Debug.Print "'Test 2' = 'Test', Ergebnis: "; "Test 2" = "Test"   ' Ergebnis: Falsch (engl. False)
Debug.Print "'Test 2' <> 'Test', Ergebnis: "; "Test 2" <> "Test" ' Ergebnis: Wahr (engl. True)
Debug.Print "'Test 2' > 'Test', Ergebnis: "; "Test 2" > "Test"   ' Ergebnis: Wahr (engl. True)
Debug.Print "'Test 2' < 'Test', Ergebnis: "; "Test 2" < "Test"   ' Ergebnis: Falsch (engl. False)
Debug.Print
'
Debug.Print "'Test' = 'Test 2', Ergebnis: "; "Test" = "Test 2"   ' Ergebnis: Falsch (engl. False)
Debug.Print "'Test' <> 'Test 2', Ergebnis: "; "Test" <> "Test 2" ' Ergebnis: Wahr (engl. True)
Debug.Print "'Test' > 'Test 2', Ergebnis: "; "Test" > "Test 2"   ' Ergebnis: Falsch (engl. False)
Debug.Print "'Test' < 'Test 2', Ergebnis: "; "Test" < "Test 2"   ' Ergebnis: Wahr (engl. True)
Debug.Print
'
Debug.Print "Null = 'Test', Ergebnis: "; Null = "Test"      ' Ergebnis: Null
Debug.Print "Null <> 'Test, Ergebnis: "; Null <> "Test"     ' Ergebnis: Null
End Sub

Zeichenfolgen mit dem Like Operator vergleichen

Mit dem Like Operator kann man eine Zeichenfolge mit einem Muster (engl. Pattern) vergleichen. Der Like Operator weist Ähnlichkeiten mit regulären Ausdrücken auf, ist aber deutlich weniger leistungsfähig. Die Syntax ist
Ergebnis = Zeichenfolge Like Muster
wobei

Ergebnis – Boolscher Wert, der angibt, ob die Erfüllung des patternstring Werts entspricht.
Zeichenfolge – Beliebiger Zeichenfolgen-Ausdruck.
Muster – Jeder String Ausdruck, der den Musterabgleichskonventionen entspricht

Für Muster können Platzhalterzeichen, Zeichenlisten oder Zeichenbereiche in einer beliebigen Kombination verwenden werden. Welche Platzhalterzeichen für Muster verwendet werden können ist der folgenden Tabelle zu sehen:

Sub Test_Like()
Dim strText As String
'
strText = "Das ist ein Test."
If strText Like "*ein*" Then
   Debug.Print "Es gibt eine Übereinstimmung, die Zeichenfolge enthält das Wort 'ein'"
Else
   Debug.Print "Keine Übereinstimmung gefunden"
End If
'
strText = "Das ist ein Test."
If strText Like "*Test?" Then
   Debug.Print "Es gibt eine Übereinstimmung, die Zeichenfolge enthält das Wort 'Test'"
Else
   Debug.Print "Keine Übereinstimmung gefunden"
End If
'
strText = "Das ist ein Test."
If strText Like "*[Tt]est?" Then
   Debug.Print "Es gibt eine Übereinstimmung, die Zeichenfolge enthält das Wort 'Test'"
Else
   Debug.Print "Keine Übereinstimmung gefunden"
End If
'
strText = "Das ist ein test."
If strText Like "*[Tt]est?" Then
   Debug.Print "Es gibt eine Übereinstimmung, die Zeichenfolge enthält das Wort 'test'"
Else
   Debug.Print "Keine Übereinstimmung gefunden"
End If
End Sub