Zeichenketten

Zeichenketten aneinanderknüpfen

Zeichenketten werden in VBA mit dem '&'-Operator aneinandergeknüpft:

Dim strText As String 

strText = "Hallo " & "liebe " 
strText = strText & "Teilnehmer!" 
MsgBox "Sie arbeiten mit " & Application.Name & " Version " & Application.Version

Besondere Zeichen

Zeilenumbruch

Für Zeilenumbrüche stehen uns mehrere Möglichkeiten zu Verfügung:

• die VBA-Konstante 'vbCrLf' (Carriage return = Schlitten einer Schreibmaschine in Ausgangsstellung bringen, Line feed = Zeilenvorschub)
• die VBA-Konstante 'vbNewLine' (vereinfachter Name für den gleichen Wert wie 'vbCrLf')
• das in der Zeichentabelle hinterlegte Zeichen für den Zeilenvorschub Chr(13)

Im praktischen Einsatz führen alle Möglichkeiten zum gleichen Ergebnis:

Dim strText As String 

strText = "Erste Zeile ..." & vbCrLf & "Zweite Zeile!" 
MsgBox strText

strText = "Erste Zeile ..." & vbNewLine & "Zweite Zeile!" 
MsgBox strText

strText = "Erste Zeile ..." & chr(13) & "Zweite Zeile!" 
MsgBox strText

Bitte beachten: Anwendungsbedingte Unterschiede können eventuell auftreten, wenn Sie Texte in Dokumente, Arbeitsblätter oder Formen schreiben.

Anführungszeichen

Das Anführungszeichen wird dazu verwendet, Klartext von der Programmierung zu trennen (ansonsten würde VBA versuchen, 'Hallo du' als eine Prozedur 'Hallo' mit dem Übergabeparameter 'du' auszuführen).

Wenn Sie innerhalb einer Zeichenkette Anführungszeichen verwenden möchten, können Sie das Anführungszeichen doppeln:

 Debug.Print "Und er sagte, ""Bitte verlassen Sie das Gebäude umgehend!"""           ' Ergibt: Und er sagte, "Bitte verlassen Sie das Gebäude umgehend!" 

Bitte beachten: Am Ende der Zeichenkette mussten hier nun drei Anführungszeichen eingesetzt werden: Zwei, um das zweite Anführungszeichen darzustellen und ein weiteres, um die Zeichenkette abzuschließen.

Weitere besondere Zeichen finden und eingeben

Asc

Die 'Asc'-Funktion liefert die Position des angegebenen Zeichens in der ASCII-Zeichentabelle zurück.

Debug.Print Asc("A") ' ergibt 65 

Bitte beachten: Die ASCII-Zeichentabelle (ASCII bedeutet 'American Standard Code for Information Interchange') enthielt ursprünglich nur die 128 Zeichen, welche im englischsprachigen Raum benötigt wurden, also Satzzeichen, Groß- und Kleinbuchstaben von A-Z und die Ziffern von 0-9.

Nicht enthalten waren Accents, Umlaute oder gar kyrillische, asiatische, arabische etc. Zeichen. Inzwischen wurden die Zeichensätze erweitert und enthalten theoretisch millionen von Zeichen.

Die 'Asc'-Funktion kann trotz ihres Namens auf mehr als die 128 Zeichen zugreifen, nämlich auf den erweiterten ASCII-Zeichensatz bis 255 (siehe Zeichentabellen). Dieser enthält zusätzlich Umlaute, Accents und weitere Zeichen, die im europäischen Raum Verwendung finden und auf dem lateinischen Alphabet basieren. Siehe hierzu auch AscW und ChrW.

Chr

Die 'Chr'-Funktion ist die Umkehr-Funktion der 'Asc'-Funktion: Sie liefert das Zeichen zurück, das an einer gegebenen Position in der Zeichentabelle steht.

 Debug.Print Chr(65) ' ergibt den Buchstaben 'A' 

Bitte beachten: Bei der 'Chr'-Funktion gelten die gleichen Anmerkungen wie zur 'Asc'-Funktion!

AscW und ChrW

Diese beiden Funktionen entsprechen den 'Asc'- und 'Chr'-Funktionen, können jedoch auf den gesamten Unicode-Zeichensatz zugreifen, welcher 65535 (2 ^16) Zeichen enthält.

Diese Funktionen sind daher für internationale Lösungen, die über die Grenzen Europas eingesetzt werden sollen, empfehlenswert.

Bitte beachten: Der VBA-Editor ist NICHT unicode-fähig! Das bedeutet, dass die Zeichen aus der Zeichentabelle über der Position 255 hier nur lückenhaft zur Verfügung stehen.

Die Office-Anwendungen sind es aber, daher können Sie in Word-Dokumenten, Excel-Zellen und PowerPoint-Folien auf den gesamten Zeichensatz zurückgreifen.

 Debug.Print Chr(1162)             ' Erzeugt Fehler: Ungültiges Argument (1162 überschreitet den Maximalwert 255)
 Debug.Print ChrW(1162)            ' Im Debug-Fenster erscheint '?', weil der VBA-Editor dieses Zeichen nicht darstellen kann
 ActiveCell.Value = ChrW(1162)     ' In der Excel-Zelle wird das tatsächliche Zeichen dargestellt: Ҋ

Zeichentabellen

Erweiterte ASCII-Tabelle bis 255

Zeichen	Keycode	VB Variable	Beschreibung
	1
	2
	3
	4
	5
	6
	7
	8
	9	vbTab	Tabstopp, Tabulator
	10	vbLf	Entspricht in manchen Anwendungen (wie XML) dem Linefeed (weicher Umbruch)
	11	vbVerticalTab	Zeilenendmarke ("Weicher Umbruch")
	12	vbFormFeed	Seitenwechsel
	13	vbCr, vbNewLine	Entspricht in manchen Anwendungen (wie Word Formularfeldern) dem Zeilenvorschub
	14		Spaltenwechsel
	15
	16
	17
	18
	19
	20
	21
	22
	23
	24
	25
	26
	27
	28
	29
—	30		Geschützter Bindestrich (STRG + UMSCHALT + MINUS)
¬	31		Bedingter Trennstrich (STRG + MINUS)
·	32		Leerzeichen
!	33
"	34
#	35
$	36
%	37
&	38
'	39
(	40
)	41
*	42
+	43
,	44
-	45
.	46
/	47
0	48
1	49
2	50
3	51
4	52
5	53
6	54
7	55
8	56
9	57
:	58
;	59
<	60
=	61
>	62
?	63
@	64
A	65
B	66
C	67
D	68
E	69
F	70
G	71
H	72
I	73
J	74
K	75
L	76
M	77
N	78
O	79
P	80
Q	81
R	82
S	83
T	84
U	85
V	86
W	87
X	88
Y	89
Z	90
[	91
\	92
]	93
^	94
_	95
`	96
a	97
b	98
c	99
d	100
e	101
f	102
g	103
h	104
i	105
j	106
k	107
l	108
m	109
n	110
o	111
p	112
q	113
r	114
s	115
t	116
u	117
v	118
w	119
x	120
y	121
z	122
{	123
|	124
}	125
~	126
&#127;	127
&#128;	128
&#129;	129
&#130;	130
&#131;	131
&#132;	132
&#133;	133
&#134;	134
&#135;	135
&#136;	136
&#137;	137
&#138;	138
&#139;	139
&#140;	140
&#141;	141
&#142;	142
&#143;	143
&#144;	144
&#145;	145
&#146;	146
&#147;	147
&#148;	148
&#149;	149
&#150;	150
&#151;	151
&#152;	152
&#153;	153
&#154;	154
&#155;	155
&#156;	156
&#157;	157
&#158;	158
&#159;	159
	160		Geschütztes Leerzeichen (Windows) (STRG + UMSCHALT + LEERTASTE)
¡	161
¢	162
£	163
¤	164
¥	165
¦	166
§	167
¨	168
©	169
ª	170
«	171
¬	172
­	173
®	174
¯	175
°	176
±	177
²	178
³	179
´	180
µ	181
¶	182
·	183
¸	184
¹	185
º	186
»	187
¼	188
½	189
¾	190
¿	191
À	192
Á	193
Â	194
Ã	195
Ä	196
Å	197
Æ	198
Ç	199
È	200
É	201
Ê	202
Ë	203
Ì	204
Í	205
Î	206
Ï	207
Ð	208
Ñ	209
Ò	210
Ó	211
Ô	212
Õ	213
Ö	214
×	215
Ø	216
Ù	217
Ú	218
Û	219
Ü	220
Ý	221
Þ	222
ß	223
à	224
á	225
â	226
ã	227
ä	228
å	229
æ	230
ç	231
è	232
é	233
ê	234
ë	235
ì	236
í	237
î	238
ï	239
ð	240
ñ	241
ò	242
ó	243
ô	244
õ	245
ö	246
÷	247
ø	248
ù	249
ú	250
û	251
ü	252
ý	253
þ	254
ÿ	255

Weitere Zeichentabellen

Weitere ausführliche Zeichentabellen finden Sie hier: Zeichentabelle

Zeichenketten umwandeln

UCase()
LCase()
Debug.Print StrConv("alle anfangsbuchstaben werden groß", vbProperCase) ' Alle Anfangsbuchstaben Werden Groß
Debug.Print StrReverse("umgekehrt") ' trhekegmu

 Private Sub StringManipulation()
    Dim strTest As String, strAnswer As String

    strTest = "Hallo liebe Schulungsteilnehmer und Herr Heß"

    strTest = UCase(strTest)
    Debug.Print strTest
    strTest = LCase(strTest)
    Debug.Print strTest
    
    ' Beispiel If-Abfrage:
    strAnswer = "Yes"
    If LCase(strAnswer) = "yes" Then
        MsgBox "Ja"
    End If
End Sub

Zeichenketten aufteilen und kürzen

Left()
Right()
Mid()
Trim()
LTrim()
RTrim()

Private Sub StringCutters()
    Dim strTest As String, strString As String
    
    strString = "Hallo liebe Schulungsteilnehmer und Herr Heß"
    
    ' Hier werden Zeichenfolgen geschnitten:
    strTest = Left(strString, 2)
    Debug.Print strTest        ' Ha
    
    strTest = Right(strString, 2)
    Debug.Print strTest        ' eß
    strTest = Mid(strString, 7, 25)
    Debug.Print strTest        ' liebe Schulungsteilnehmer
    
    ' Die Trim-Funktionen entfernen Leerzeichen (auch mehrere) vom Anfange und/oder Ende des Textes
    strString = " Trim Me "
    Debug.Print "'" & strString & "'"     ' Trim Me '
    
    strTest = LTrim(strString)
    Debug.Print "'" & strTest & "'"       'Trim Me '
    strTest = RTrim(strString)
    Debug.Print "'" & strTest & "'"       ' Trim Me'
    strTest = Trim(strString)
    Debug.Print "'" & strTest & "'"       'Trim Me'
End Sub

In Zeichenketten ersetzen

Die Funktion für das Ersetzen von Teilen einer Zeichenkette heißt 'Replace'.

Private Sub StringReplace()
    Dim strString As String ' Suchen und Ersetzen von Zeichenfolgen
    strString = "Ich werde gesucht und ersetzt"
    Debug.Print strString
    Debug.Print Replace(strString, "gesucht", "gefunden")
    
    ' Groß- / Kleinschreibung wird beachtet!
    Debug.Print Replace(strString, "Gesucht", "gefunden")
    ' vbTextCompare: Groß- / Kleinschreibung wird ignoriert!
    Debug.Print Replace(strString, "Gesucht", "gefunden", , , vbTextCompare)
End Sub 

Das reine 'Replace' führt die Ersetzung jedoch nur in einem Durchlauf durch, daher können mehrfach hintereinander auftretende Treffer eventuell nicht alle ersetzt werden (zur besseren Darstellung werden '+'-Zeichen statt Leerzeichen verwendet):

Debug.Print Replace("++Text+++++mit+++überschüssigen+Leerzeichen+...+", "++", "+")

Das Ergebnis (enthält immer noch doppelte Leerzeichen):

+Text+++mit++überschüssigen+Leerzeichen+...+ 

Mit einer selbst geschriebenen Funktion 'ReplaceRecursively' kann dem abhilfe geschaffen werden:

• Der ursprüngliche Text wird in einer Variablen gespeichert.
• Das Ersetzen mit 'Replace' wird durchgeführt (mit Rücksicht auf die optionale Angabe zur Groß- und Kleinschreibung).
• Wenn durch das Ersetzen eine Änderung am Text erfolgt ist, wird die Funktion nochmals aufgerufen (siehe Rekursionen).
• Hierbei wird das Ergebnis des Ersetzens als neuer Ausgangstext verwendet.

Public Function ReplaceRecursively(ByVal strInText As String, ByVal strFind As String, ByVal strReplace As String, Optional ByVal blnMatchCase As Boolean) As String
    Dim strTemp As String
    
    strTemp = strInText
    If blnMatchCase = True Then
        ReplaceRecursively = Replace(strInText, strFind, strReplace)
    Else
        ReplaceRecursively = Replace(strInText, strFind, strReplace, , , vbTextCompare)
        End If
    If strTemp <> ReplaceRecursively Then             
        ReplaceRecursively = ReplaceRecursively(ReplaceRecursively, strFind, strReplace, blnMatchCase)     ' rekursiver Aufruf der eigenen Funktion wirkt wie eine Schleife
    End If
End Function

Debug.Print ReplaceRecursively("++Text+++++mit+++überschüssigen+Leerzeichen+...+", "++", "+")

Ergebnis nun:

+Text+mit+überschüssigen+Leerzeichen+...+

Position innerhalb einer Zeichenkette, Länge ermitteln

InStr() InStrRev() Len()

Private Sub StringMath()
    Dim strTest As String, strString As String
    Dim lngPosition As Long, lngLength As Long
    strString = "Hallo liebe Schulungsteilnehmer und Herr Heß"
    ' Ermittlung der Länge einer Zeichenkette:
    lngLength = Len(strString)
    Debug.Print "Die Zeichenkette enthält " & lngLength & " Zeichen"
    
    ' Ermittlung von Zeichenpositionen:
    lngPosition = InStr(strString, " ")
    Debug.Print "Erstes Leerzeichen an Position: " & lngPosition
    
    ' bei der Suche nach dem nächsten Leerzeichen die letzte Position + 1 als Anfangsposition verwenden!
    lngPosition = InStr(lngPosition + 1, strString, " ")
    Debug.Print "Zweites Leerzeichen an Position: " & lngPosition
    
    lngPosition = InStr(strString, "y")
    Debug.Print "'y' an Position: " & lngPosition
    
    lngPosition = InStr(strString, "Schul")
    Debug.Print "'Schul' beginnt an Position: " & lngPosition
    
    ' InStr und InStrRev achten auf Groß- / Kleinschreibung!
    
    lngPosition = InStr(strString, "schul")
    Debug.Print "'schul' (klein geschrieben!) an Position: " & lngPosition
    ' Wenn die Groß- / Kleinschreibung nicht berücksichtigt werden soll,
    ' kann der Parameter 'Compare' auf 'vbTextCompare' geändert werden.
    ' Dann muss allerdings auch der Anfangspunkt angegeben werden:
    lngPosition = InStr(1, strString, "SCHul", vbTextCompare)
    Debug.Print "'SCHul' (Groß-/Kleinschreibung nicht beachten!) an Position: " & lngPosition
    
    ' InStrRev findet die letzte Position einer Zeichenkette innerhalb der vorgegebenen Zeichenkette
    ' Die Position wird weiterhin von links gesehen angegeben
    lngPosition = InStrRev(strString, " ")
    Debug.Print "Letztes Leerzeichen an Position: " & lngPosition
    
    ' bei der Suche nach dem vorhergehenden Leerzeichen die letzte Position - 1 als Anfangsposition verwenden!
    lngPosition = InStrRev(strString, " ", 41 - 1)
    Debug.Print "Vorletztes Leerzeichen an Position: " & lngPosition
End Sub

Zeichenkette erzeugen

Mithilfe der String-Funktion können Sie eine Zeichenkette erzeugen, die eine angegebene Anzahl von Wiederholungen des gleichen Buchstaben enthält:

Debug.Print String(3, "A")         ' Ergibt 'AAA' 

In einem 'Like'-Vergleich können wir dies wie folgt einsetzen:

Public Function IsNumber(ByVal strNumber As String) As Boolean

    IsNumber = True
    If strNumber Like String(Len(strNumber), "#") Then
        Exit Function
    End If
    IsNumber = False
End Function

Die Anweisung 'String(Len(strNumber), "#")' erzeugt einen Vergleichs-Text, der aus so vielen '#' besteht, wie Zeichen im übergebenen String sind. Hiermit wird also festgestellt, ob strNumber ausschließlich aus Ziffern besteht, also eine Ganzzahl ist.

Beispiele

Public Function LastWord(ByVal strText As String) As String
    Dim strWord As String
    Dim lngPosition As Long
    
    lngPosition = InStrRev(strText, " ")
    strWord = Right(strText, Len(strText) - lngPosition)
    LastWord = strWord
End Function

Private Function LastWordMid(ByVal strText As String) As String
    Dim strWord As String
    Dim lngPosition As Long
    
    lngPosition = InStrRev(strText, " ")
    strWord = Mid(strText, lngPosition + 1)
    LastWordMid = strWord
End Function

Public Function FirstWord(ByVal strText As String) As String
    Dim strWord As String
    Dim lngPosition As Long
    
    lngPosition = InStr(strText, " ")
    If lngPosition < = 0 Then
        strWord = strText
    Else
        strWord = Left(strText, lngPosition - 1)
    End If
    FirstWord = strWord
End Function

Public Function AnyWord(ByVal strText As String, ByVal lngIndex As Long) As String
    Dim strWord As String
    Dim lngPos1 As Long, lngPos2 As Long, lngWord As Long
    Dim blnLastItem As Boolean
    
    lngPos1 = 1
    For lngWord = 1 To lngIndex
        If blnLastItem = True Then
            strWord = ""
            Exit For
        End If
        lngPos2 = InStr(lngPos1, strText, " ")
        If lngPos2 < = 0 Then
            If lngPos1 < = 1 Then
                strWord = strText
                blnLastItem = True
            Else
                strWord = Mid(strText, lngPos1)
                blnLastItem = True
            End If
        Else
            strWord = Mid(strText, lngPos1, lngPos2 - lngPos1)
        End If
        lngPos1 = lngPos2 + 1
    Next lngWord
    AnyWord = strWord
End Function

Public Function ListItem(ByVal strList As String, ByVal lngItem As Long, Optional ByVal strSeparator As String = ",") As String
    Dim strWord As String
    Dim lngPos1 As Long, lngPos2 As Long, lngWord As Long, lngOffset As Long
    Dim blnLastItem As Boolean
    
    lngPos1 = 1
    For lngWord = 1 To lngItem
        If blnLastItem = True Then
            strWord = ""
            Exit For
        End If
        If lngWord > 1 Then
            lngOffset = Len(strSeparator) - 1
        End If
        lngPos2 = InStr(lngPos1, strList, strSeparator)
        If lngPos2 < = 0 Then
            If lngPos1 < = 1 Then
                strWord = strList
                blnLastItem = True
            Else
                strWord = Mid(strList, lngPos1 + lngOffset)
                blnLastItem = True
            End If
        Else
            strWord = Mid(strList, lngPos1 + lngOffset, lngPos2 - lngPos1 - lngOffset)
        End If
        lngPos1 = lngPos2 + 1
    Next lngWord
    ListItem = strWord
End Function