Zeichenfolgen

Computer kennen streng genommen keine Zeichen, sondern nur Zahlen. Um ein Zeichen zu speichern, muss ihm ein Zahlenwert zugeordnet sein, und der Computer „übersetzt“ diesen Zahlenwert dann anhand einer Zuordnungstabelle in Buchstaben. Die früher verbreitetste Zuordnungstabelle war ASCII, die den Werten 0-127 Zeichen zuordnete. Später wurde die ASCII-Tabelle um Zeichen im Wertebereich 160-255 ergänzt. Das nannte sich die ANSI-Tabelle. Microsoft ergänzte ANSI wiederum um die Zeichen 128-159 und nannte dies WINDOWS-1252. Bis heute ist dies der Zeichenumfang, der innerhalb VBA zur Verfügung steht. Um aus der folgenden Tabelle den Zeichenwert eines Zeichens auszulesen, muss man den Spalten- und Zeilenwert addieren. „A“ hat also den Zeichenwert 64 + 1 = 65.

Zeichen mit einem Wert kleiner 32 sind sogenannte „Steuerzeichen“, die heute überwiegend bedeutungslos sind (ASCII stammte aus der Lochkartenzeit). In VBA gibt es für einige davon noch Konstanten, von denen heute nur die Zeichen für den Zeilenumbruch halbwegs interessant wären - wenn sie sich nicht zu allem Überfluss je nach Betriebssystem unterscheiden würden. Die Konstante vbNewLine wählt aber in Abhängigkeit zum Betriebssystem das „richtige“ Steuerzeichen aus, womit dann auch dieses Problem erledigt wäre.

Office verwendet heute nicht mehr WINDOWS-1252, sondern den UTF-16-Zeichensatz, der jedes Zeichen in zwei Byte speichert, womit über 65.000 Zeichen zur Verfügung stehen. Die ersten 255 Zeichen von UTF-16 sind mit ANSI identisch. Die Zeichen 128-159 (in der Tabelle rot markiert) sind in UTF-16 dagegen nicht mit den Zeichen aus WINDOWS-1252 belegt, sondern mit weiteren Steuerzeichen. Die Nutzung dieser Zeichen kann daher in Extremfällen Probleme verursachen.

Für die folgenden Funktionen, die eine Zeichenfolge zurückgeben, gibt es noch eine Version mit nachgestelltem „$“ (z. B. Chr$). Dann ist der Rückgabewert nicht Variant, sondern String.

Asc, AscW

Asc(String As String) As Integer

Erwartet einen String als Argument, der mindestens ein Zeichen lang sein muss. Ist er länger, wird nur das erste Zeichen ausgewertet. Für dieses Zeichen wird der Zeichencode gemäß der Zuordnungstabelle zurückgegeben.

Debug.Print Asc("A")
 65

Mit AscW kann der Zeichencode gemäß UTF-16 zurückgegeben werden.

Chr, ChrW

Chr(CharCode As Long) As Variant

Erwartet eine positive Ganzzahl als Argument und gibt das zugehörige Zeichen aus der Zuordnungstabelle als String zurück.

Debug.Print Chr(65)
A

Mit ChrW kann ein Zeichen gemäß UTF-16 zurückgegeben werden. Ist die Darstellung nicht möglich, wird ein „?“ angezeigt.

Format

Format(Expression As Variant, [Format As String], [FirstDayOfWeek As VbDayOfWeek = vbSunday], [FirstWeekOfYear As VbFirstWeekOfYear = vbFirstJan1]) As Variant

Gibt die Zeichenfolge Expression wieder zurück. Mit dem Argument Format kann der Rückgabewert formatiert werden. Dafür steht eine Reihe benannter Formate zur Verfügung.

Debug.Print Format(1000,"Fixed")
1000,00
Debug.Print Format(1000,"Scientific")
1,00E+03

Anstelle eines benannten Formats kann auch ein benutzerdefiniertes Format verwendet werden. Dazu wird für jede Stelle des Ausgabestrings ein sogenanntes Platzhalterzeichen gesetzt, der das Aussehen bestimmt

Andere Zeichen in Format als die in den benutzerdefinierten Formaten definierten werden unverändert angezeigt. Will man eines der obigen Platzhalterzeichen selbst im Ausgabestring anzeigen, sollte man einen umgekehrten Schrägstrich voranstellen.

Debug.Print Format(1000,"#,000.00 $")
1.000,00 $
Debug.Print Format(1000,"@@@@@@@@@@ \q\m")
      1000 qm
Debug.Print Format(,"m")

Für das benutzerdefinierte Datumsformat „w“ gibt es das Argument FirstDayOfWeek, für das mit der Aufzählung VbDayOfWeek festgelegt werden kann, welcher Wochentag der Erste ist.

Für das benutzerdefinierte Datumsformat „ww“ gibt es das Argument FirstWeekOfYear, für das mit der Aufzählung VbFirstWeekOfYear festgelegt werden kann, welche Woche des Jahres die Erste ist.

FormatCurrency

FormatCurrency(Expression As Variant, [NumDigitsAfterDecimal As Long = -1], [IncludeLeadingDigit As VbTriState = vbUseDefault], [UseParensForNegativeNumbers As VbTriState = vbUseDefault], [GroupDigits As VbTriState = vbUseDefault]) As String

Gibt Expression als Zeichenfolge zurück, die als Währungswert formatiert ist. Es wird das Währungssymbol aus den Systemeinstellungen verwendet.

Mit NumDigitsAfterDecimal kann man angeben, wie viele Nachkommastellen zurückgegeben werden sollen. Hat Expression mehr Nachkommastellen, wird gerundet. Bei „−1“ greifen die Systemeinstellungen. Andere negative Zahlen für NumDigitsAfterDecimal verursachen einen Fehler.

Mit IncludeLeadingDigit kann man angeben, ob bei Zahlen kleiner 1 eine führende 0 angezeigt wird, mit UseParensForNegativeNumbers, ob bei negativen Zahlen Klammern anstelle eines Minus angezeigt wird und mit GroupDigits, ob Zahlen ab 1.000 in Dreiergruppen mit Trennzeichen gruppiert werden sollen.

Hinweis: Die Format-Funktion bietet weitergehende Möglichkeiten als die FormatCurrency-Funktion. Lediglich das Währungssymbol kann dort nicht aus den Systemeinstellungen übernommen werden.

Debug.Print FormatCurrency(1000)
1.000,00 €

FormatDateTime

FormatDateTime(Expression As Variant, [NamedFormat As VbDateTimeFormat = vbGeneralDate]) As String

Gibt Expression als Zeichenfolge zurück, die als Datum/Zeit formatiert ist. Das genaue Aussehen kann über NamedFormat bestimmt werden, für das die Aufzählung VbDateTimeFormat zur Verfügung steht.

Hinweis: Die Format-Funktion bietet weitergehende Möglichkeiten als die FormatDateTime-Funktion.

FormatNumber

FormatNumber(Expression As Variant, [NumDigitsAfterDecimal As Long = -1], [IncludeLeadingDigit As VbTriState = vbUseDefault], [UseParensForNegativeNumbers As VbTriState = vbUseDefault], [GroupDigits As VbTriState = vbUseDefault]) As String

Gibt Expression als String zurück, der als Zahl formatiert ist.

Mit NumDigitsAfterDecimal kann man angeben, wie viele Nachkommastellen zurückgegeben werden sollen. Hat Expression mehr Nachkommastellen, wird gerundet. Bei „−1“ greifen die Systemeinstellungen. Andere negative Zahlen für NumDigitsAfterDecimal verursachen einen Fehler.

Mit IncludeLeadingDigit kann man angeben, ob bei Zahlen kleiner 1 eine führende 0 angezeigt wird, mit UseParensForNegativeNumbers, ob bei negativen Zahlen Klammern anstelle eines Minus angezeigt wird und mit GroupDigits, ob Zahlen ab 1.000 in Dreiergruppen mit Trennzeichen gruppiert werden sollen.

Hinweis: Die Format-Funktion bietet weitergehende Möglichkeiten als die FormatNumber-Funktion.

FormatPercent

FormatPercent(Expression As Variant, [NumDigitsAfterDecimal As Long = -1], [IncludeLeadingDigit As VbTriState = vbUseDefault], [UseParensForNegativeNumbers As VbTriState = vbUseDefault], [GroupDigits As VbTriState = vbUseDefault]) As String

Gibt Expression als Zeichenfolge zurück, die als Prozentzahl formatiert ist.

Mit NumDigitsAfterDecimal kann man angeben, wie viele Nachkommastellen zurückgegeben werden sollen. Hat Expression mehr Nachkommastellen, wird gerundet. Bei „−1“ greifen die Systemeinstellungen. Andere negative Zahlen für NumDigitsAfterDecimal verursachen einen Fehler.

Mit IncludeLeadingDigit kann man angeben, ob bei Zahlen kleiner 1 eine führende 0 angezeigt wird, mit UseParensForNegativeNumbers, ob bei negativen Zahlen Klammern anstelle eines Minus angezeigt wird und mit GroupDigits, ob Zahlen ab 1.000 in Dreiergruppen mit Trennzeichen gruppiert werden sollen.

Hinweis: Die Format-Funktion bietet weitergehende Möglichkeiten als die FormatPercent-Funktion.

Debug.Print FormatPercent(1.1)
110,00%

InStr

InStr([Start As Long], String1 As Variant, String2 As Variant, [Compare As VbCompareMethod = vbBinaryCompare]) As Long

Prüft, ob String2 in String1 enthalten ist. Trifft es zu, gibt die Funktion zurück, an der wievielten Stelle die gesuchte Zeichenfolge das erste Mal auftritt. Ansonsten wird „0“ zurückgegeben.

Mit Start kann der Funktion eine positive Zahl übergeben werden, die angibt, ab der wievielten Stelle innerhalb von String1 nach String2 gesucht werden soll. Darüber hinaus kann noch mit dem Argument Compare ein Wert aus der Aufzählung VbCompareMethod ausgewählt werden, um anzugeben, wie verglichen werden soll. Wird Compare angegeben, muss zwingend auch Start angegeben werden.

Debug.Print InStr("Fliegen fliegen hinter Fliegen", "fliegen")
 9
Debug.Print InStr(1, "Fliegen fliegen hinter Fliegen", "fliegen", vbTextCompare)
 1

InStrRev

InStrRev(StringCheck As String, StringMatch As String, [Start As Long = -1],  [Compare As VbCompareMethod = vbBinaryCompare]) As Long

Mit der InstrRev-Funktion kann man prüfen, ob StringMatch in StringCheck enthalten ist. Trifft es zu, gibt die Funktion zurück, an der wievielten Stelle die gesuchte Zeichenfolge das letzte Mal auftritt. Ansonsten wird „0“ zurückgegeben.

Mit Start kann der Funktion eine positive Zahl übergeben werden, die angibt, ab der wievielten Stelle von Links innerhalb von StringCheck nach StringMatch gesucht werden soll. Wird Start nicht angegeben oder auf „-1“ gesetzt, wird von hinten gesucht. Andere Werte als positive Zahlen oder „-1“ verursachen einen Fehler.

Mit dem Argument Compare kann noch ein Wert aus der Aufzählung VbCompareMethod ausgewählt werden, um anzugeben, wie verglichen werden soll.

Achtung: Obwohl InStrRev der Funktion InStr sehr ähnelt, sind die Argumente anders angeordnet.

Debug.Print InStrRev("Fliegen fliegen hinter Fliegen","Fliegen")
 24
Debug.Print InStrRev("Fliegen fliegen hinter Fliegen","Fliegen", 20)
 1

LCase

LCase(String As String) As Variant

LCase wandelt alle Großbuchstaben im Argument String in Kleinbuchstaben um. Alle anderen Zeichen werden unverändert zurückgegeben.

Debug.Print LCase("17 Euro")
17 euro

Left

Left(String As Variant, Length As Long) As Variant

Gibt von String den linken Teil zurück, und zwar so viele Zeichen, wie in Length angegeben. Length darf nicht negativ sein.

Debug.Print Left("Donaudampfschiff", 5)
Donau

Len, LenB

Len(Expression As Variant) As Long

Sofern Expression den Datentyp String hat, wird die Länge des Strings zurückgegeben. Bei anderen Datentypen wird der Speicherbedarf von Expression zurückgegeben.

Debug.Print Len("ABC")
 3

LenB funktioniert identisch. Ist Expression allerdings vom Datentyp String, werden je Zeichen zwei Byte gezählt, weil LenB Zeichen gemäß UTF-16 berechnet.

LTrim

LTrim(String As Variant) As Variant

Sofern String führende Leerzeichen hat, werden diese entfernt. Der Rest des Strings wird zurückgegeben.

Debug.Print LTrim("   ABC")
ABC

Mid

Mid(String As Variant, Start As Long, [Length As Long]) As Variant

Extrahiert aus String eine Teilzeichenkette, und zwar ab Start so viele Zeichen, wie mit Length angegeben. Start muss positiv sein. Fehlt Length, wird String bis zum Ende ausgegeben. Length darf nicht negativ sein.

Debug.Print Mid("Donaudampfschiff", 6, 5)
dampf

Mid kann auch Rechts von einem Gleichheitszeichen stehen. Dann wird die ermittelte Teilzeichenkette durch die Zeichenfolge Rechts vom Gleichheitszeichen ersetzt.

Sub ersetze()
Dim Boot As String

Boot = "Donaudampfschiff"
Mid(Boot, 6, 5) = "segel"   'Neuer Wert: "Donausegelschiff"
Debug.Print Boot

End Sub

Replace

Replace(Expression As String, Find As String, Replace As String, [Start As Long = 1], [Count As Long = -1], [Compare As VbCompareMethod = vbBinaryCompare]) As String

Sucht in Expression nach Find und ersetzt es durch Replace. Mit Start kann angegeben werden, ab der wievielten Stelle in Expression die auszugebende Zeichenkette beginnt. Start muss positiv sein. Mit Count kann angegeben werden, wie oft ersetzt werden soll, falls Find mehr als einmal gefunden wird. Hat Count den Wert „-1“, werden alle Treffer ersetzt.

Mit dem Argument Compare kann noch ein Wert aus der Aufzählung VbCompareMethod ausgewählt werden, um anzugeben, wie verglichen werden soll.

Debug.Print Replace("ABC ABC ABC Abc", "AB", "XY")
XYC XYC XYC Abc
Debug.Print Replace("ABC ABC ABC Abc", "AB", "XY", 2)
BC XYC XYC Abc
Debug.Print Replace("ABC ABC ABC Abc", "AB", "XY", ,1)
XYC ABC ABC Abc
Debug.Print Replace("ABC ABC ABC Abc", "AB", "XY", , ,vbTextCompare)
XYC XYC XYC XYc

Right

Right(String As Variant, Length As Long) As Variant

Gibt von String den rechten Teil zurück, und zwar so viele Zeichen, wie in Length angegeben. Length darf nicht negativ sein.

Debug.Print Right("Donaudampfschiff", 6)
schiff

RTrim

RTrim(String As Variant) As Variant

Sofern String Leerzeichen am Ende hat, werden diese entfernt. Der Rest des Strings wird zurückgegeben.

Debug.Print RTrim("ABC   ") & "Z"
ABCZ

Space

Space(Number As Long) As Variant

Gibt eine Zeichenfolge zurück, die aus Number Leerzeichen besteht.

Debug.Print Space(5) & "Z"
     Z

StrComp

StrComp(String1 As Variant, String2 As Variant, [Compare As VbCompareMethod = vbBinaryCompare]) As Integer

Vergleicht String1 und String2 alphabetisch oder anhand der Zuordnungstabelle (Abhängig von Compare).

Liegt String1 vor String2, wird „-1“ zurückgegeben, liegt String1 nach String2, wird „1“ zurückgegeben. Sind sie gleich, wird „0“ zurückgegeben. Hat einer der beiden Strings den Wert Null, ist auch der Rückgabewert Null.

StrConv

StrConv(String As Variant, Conversion As VbStrConv, [LocaleID As Long]) As Variant

Wandelt String anhand der Einstellungen von Conversion um.

Einige der Einstellungen verursachen auf Systemen ohne Gebietseinstellungen für Japan oder Fernost einen Laufzeitfehler.

Debug.Print StrConv("aBc def", vbProperCase)
Abc Def

String

String(Number As Long, Character As Variant) As Variant

Wenn Character eine Zeichenfolge ist, wird dessen erstes Zeichen so oft wiederholt, wie mit Number angegeben. Ist Character eine Zahl, wird sie als entsprechendes Zeichen der Zuordnungstabelle interpretiert, bei Zahlen größer 255 oder kleiner 0 wird die Zahl Modulo 256 berechnet.

Number darf nicht negativ sein.

Debug.Print String(5, "A")
AAAAA

StrReverse

StrReverse(Expression As String) As String

Kehrt einen String um.

Debug.Print StrReverse("Ehetum mit Ella nennen alle, Tim, Mutehe")
ehetuM ,miT ,ella nennen allE tim mutehE

Trim

Trim(String As Variant) As Variant

Sofern String Leerzeichen am Anfang oder Ende hat, werden diese entfernt. Der Rest des Strings wird zurückgegeben.

Debug.Print RTrim("   ABC   ") & "Z"
ABCZ

UCase

UCase(String As Variant) As Variant

UCase wandelt alle Kleinbuchstaben im Argument String in Großbuchstaben um. Alle anderen Zeichen werden unverändert zurückgegeben.

Debug.Print UCase("17 Euro")
17 EURO