VBA-Array

Arrays (Listen, Vektoren) in VBA

Ein Array ( Liste, Vektor, Datenfeld, .. ) fasst mehrere Variable unter einem gemeinsamen Namen zusammen. Auf dieser Seite finden sie eine Zusammenstellung von Themen zur Verwendung von Arrays in Javascript.
Damit sollen bestehende Referenzen und Tutorials ergänzt werden.
VBA Visual Basic for Applications
Type Typen von VBA-Arrays
Definition & Initialisierung Erzeugung und Initialisierung, Geltungsbereich von Arrays
Eigenschaften Type, Anzahl der Elemente eines Arrays
Lesen & Schreiben Einfacher Zugriff auf Array-Elemente
Schleifen Bearbeitung von Array-Elementen in Schleifen (loops)
Mehrdimensionale Arrays Tabellen, Arrays in 2, 3 und mehr Dimensionen
Bereich Daten-Austausch Kalkulations-Bereich ↔ VBA-Array
Array → Funktion Arrays als Argumente an Unterprogramme übergeben
Funktion → Array Arrays aus Funktionen zurückgeben
Verweise Lookup mit Arrays
Push() & Pop() Stack-Funktionen mit VBA-Arrays
Split() & Join() Spalten und Zusammenfügen von 'strukturiertem Text' - Details
Verwandte Themen Arrays in Javascript, Perl, PHP
Links Ausgewählte Links zum Thema 'VBA @ Array'

Typen von VBA-Arrays
VBA verwendet nur Arrays einheitlicher Typen, d.h. alle Elemente eines Arrays haben den gleichen Daten-Typ.
Für die Verwendung unterschiedlicher Datentypen müssen mehrere Arrays angelegt werden. 		Zur Kennzeichnung und Unterscheidung der einzelnen Elemente wird eine ganze Zahl>=0 verwendet, dafür sind die Begriffe Schlüssel und/oder Index üblich.

Array-Typen

VBA verwendet diese Standard-Typen für Variable:
Boolean (True,False),
Byte (1 Byte ganze Zahlen 0..255),
Integer (2 Byte ganze Zahlen -32768..32767),
Long (4 Byte ganze Zahlen -2147483648..2147483647),
Single (4 Byte Gleitkomma-Zahlen -3.4E38..+3.4E38),
Double (8 Byte Gleitkomma-Zahlen -1.8E308..+1.8E308),
String (Text variabler Länge bis zu 2^31 = 2 Mia Zeichen)
Arrays jeder Variablen-Type können verwendet werden, z.B.
Dim i(10) As Integer
deklariert ein Array vom Type Integer, das 11 (!) einzelne Variable dieses Typs mit den Namen i(0) bis i(10) enthält.

Der Typ Date ist identisch mit Double, da VBA Datum und Zeit im Y1900-Format speichert. VBA kann auch Arrays vom Typ Date verwalten.
Der Typ Variant kann für ganze Zahlen, Gleitkomma-Zahlen oder Texte variabler Länge verwendet werden. Der Zusammenhang entscheidet, wie eine Variant-Variable interpretiert wird, d.h. es wird nicht zwischen einem String "123" und einer ganzen Zahl 123 unterschieden. Das ist für unerfahrene EntwicklerInnen ein Vorteil.
Im professionellen Bereich sollte man Variant vermeiden. Durch die unklare Interpretation werden schwer zu findende Programmier-Fehler begünstigt, außerdem benötigen Variant-Variable mehr Speicherplatz und mehr Zeit zur Verarbeitung.
Alle Variable und Arrays, deren Type nicht ausdrücklich deklariert ist, werden VBA-intern als Variant geführt. Daher sind folgende Deklarationen äquivalent
Dim v(100) As Variant
Dim v(100)

Auch andere spezielle Datentypen sind möglich, werden hier jedoch nicht vorgestellt.

Index

Ohne besondere Vereinbarung gilt:
Das erste Array-Element trägt den Index (0), das zweite (1) usw.
Der Index kann auch in anderen Zahlen-Bereichen angesiedelt werden:
Dim a(100 To 200) As Integer
deklariert ein Array a mit Index (100) bis (200)

Anweisung Option Base

Mit der Anweisung
Option Base 0
kann (am Modul-Anfang, vor dem Programmcode) vereinbart werden, dass der Index von Arrays ohne besondere Vereinbarung bei (0) beginnt.
Das ist Standard in allen gängigen Programmiersprachen.
Man kann auch Option Base 1 vereinbaren, davon wird jedoch abgeraten, weil es der Praxis üblicher Programmierung widerspricht.

Definition & Initialisierung von VBA-Arrays

Option Explicit

Es wird unbedingt empfohlen, diese Vereinbarung an den Beginn jedes VBA-Programms zu stellen. Sie erzwingt die ausdrückliche Vereinbarung (Deklaration) aller Variablen und Arrays.
Jeder Versuch, eine Variable oder ein Array ohne vorherige ausdrückliche Deklaration zu verwenden, wird verhindert, die entsprechende Programmzeile angezeigt.

Deklaration

Die Vereinbarung von Arrays erfolgt mit der Dim-Anweisung, gefolgt vom Array-Namen, der Dimension und der Type:
Dim t(123) As String
vereinbart ein Array von Texten variabler Länge aus 124 Elementen t(0) bis t(123)
Eine Vereinbarung kann auch mehrere Variable und Arrays des gleichen Typs enthalten:
Dim x(100), y(100), z As Single
vereinbart die beiden Arrays x und y sowie die (skalare) Variable z als Gleitkomma-Zahlen geringer Genauigkeit.

Geltungsbereich

Jedes Array ist ebenso wie jede andere Variable nur innerhalb eines bestimmten Bereichs gültig.

Lokale Arrays
Jedes Array, das innerhalb einer Function oder eines Sub definiert wird, ist ausschließlich innerhalb des betreffenden Unterprogramms gültig. Bei Aufruf des Unterprogramms wird Speicherplatz für die darin definierten Arrays bereitgestellt. Dabei werden die einzelnen Array-Elemente zwar automatisch auf Anfangswerte gesetzt (z.B. Zahlen auf 0), darauf sollten sie sich jedoch nicht verlassen. Betrachten sie die Daten als undefiniert und führen sie selbst die Initialisierung (Festlegung der Anfangswerte) durch.

Nach Verlassen des Unterprogramms wird dessen Speicherplatz freigegeben, die Daten lokaler Arrays sind daher wieder undefiniert, insbesondere bei erneutem Aufruf des gleichen Programms.
Ein lokal definiertes Array kann nicht durch andere Unterprogramme verwendet werden, in anderen Unterprogrammen können Variable und Arrays mit den gleichen Namen verwendet werden.

Im Beispiel rechts wird von jeder der beiden Funktionen ein Array mit dem gleichen (!) Namen definiert, trotzdem gibt es keine Kollision, da beide Arrays nur innerhalb ihrer Funktionen gültig sind. Function t_1 liefert bei jedem Aufruf das Ergebnis 33, Function t_2 immer das Ergebnis 66.
Function t_3 löst einen Fehler aus, weil sie auf keines der beiden lokalen Arrays x zugreifen kann. 		Lokale VBA-Arrays
Function t_1
Dim x(10) As Integer
x(3) = 33
t_1 = x(3)
End Function

Function t_2
Dim x(10) As Integer
x(3) = 66
t_2 = x(3)
End Function

Fnction t_3
t_3 = x(3)   ' Fehler !
End Function
Statische Arrays
sind ebenfalls nur innerhalb ihrer Function oder ihres Sub gültig. Nach Verlassen der Unterprogramme wird der Speicherplatz jedoch nicht freigegeben, alle statischen Variablen und Arrays behalten daher ihre aktuellen Daten.
Sie müssen daher durch geeignete Programmierung sicherstellen, dass statische Arrays bei Bedarf initialisiert werden, danach jedoch ohne Initialisierung weiter verwendet werden.

Im Beispiel wird die Function t_4 als Zähler verwendet. Mit dem Wert WAHR (True) als Argument wird der Zähler initialisiert (auf die Zahl 0 gesetzt). Mit Argument FALSCH (False) wird der Wert von Array-Element (5) bei jedem Aufruf der Funktion um +1 erhöht und zurückgegeben. Jedes Element von Array x behält seinen Wert auch nach dem Ende von Funktion t_4. 		Ein statisches VBA-Array
Function t_4(init As Boolean) As Integer
Static x(10) As Integer
If init Then
x(5) = 0
Else
x(5) = x(5) + 1
End If
t_4 = x(5)
End Function
Globale Arrays
werden am Modul-Anfang deklariert, d.h. vor und außerhalb irgendeiner Function oder eines Sub. Der Geltungsbereich umfasst das gesamte VBA-Modul, d.h. ein global definiertes Array kann in jedem Programm, in jedem Sub und in jeder Function dieses Moduls verwendet werden. Ein globales Array ist gleichzeitig Static, d.h. die Array-Elemente behalten ihre Werte unabhängig von Unterprogramm-Aufrufen.
Von anderen Modulen ist kein Zugriff möglich.

Im Beispiel erfolgt die Initialisierung durch Aufruf der Function t_5, während Function t_6 als Zähler dient. Das globale Array y wird innerhalb der Funktionen nicht mehr definiert !
Function t_7 verwendet ein eigenes lokales Array mit dem gleichen Namen. Das ergibt keine Kollision, d.h. VBA verwendet das globale Array y für die beiden Functions t_5 und t_6, das lokale Array y für Function t_7 (die immer den Wert 777 zurückgibt).
Das ist schlechter Programmier-Stil - man sollte unterschiedliche Namen verwenden, um Verwechslungen zu vermeiden - Das Beispiel dient lediglich zur Demonstration der Reichweite von Array-Deklarationen. 		Ein globales VBA-Array
Dim y(10) As Integer

Function t_5() As Integer
y(7) = 0
t_5 = y(7)
End Function

Function t_6() As Integer
y(7) = y(7) + 1
t_6 = y(7)
End Function

Function t_7() As Integer
Dim y(10) As Integer
y(7) = 777
t_7 = y(7)
End Function
Vorteil einer globalen Deklaration ist die Verwendbarkeit in allen Programmteilen eines Moduls. Insbesondere braucht man solche Arrays weder an Unterprogramme übergeben noch von ihnen zurückgeben. Das ist sinnvoll, wenn die Elemente solcher Arrays von mehreren Programmteilen bearbeitet werden. Nachteil der globalen Deklaration ist die geringere Übersicht sowie der größere Bedarf an Speicherplatz. Deklarieren sie so wenige Arrays wie möglich global, aber verwenden sie diese Möglichkeit gezielt für solche Daten, die tatsächlich die allgemeine Daten-Grundlage eines Moduls darstellen.

Array-Anweisung

Mit der Array-Anweisung wird ein Array der Type Variant definiert und initialisiert, d.h. es werden Anfangswerte in alle Elemente eingetragen.
Die Array-Anweisung kann sowohl für lokale als auch für globale Arrays verwendet werden, jedoch leider nicht für Arrays anderer Typen als Variant.
a = Array(10,20,30)
wotag = Array("Mo", "Di", "Mi", "Do", "Fr", "Sa", "So")

Dynamische Dimensionierung, Löschen

Mit der Redim-Anweisung ist es möglich, die Größe jedes Arrays nachträglich zu ändern. Im Beispiel wird das Array b zunächst ohne Elemente deklariert. Zu einem späteren Zeitpunkt wird die Redim-Anweisung ausgeführt, damit werden 100 Elemente b(0) bis b(100) reserviert.
Achtung - Nach Redim sind die Werte aller Array-Elemente undefiniert, bzw. werden die vorhandenen Werte der Elemente durch Redim zerstört.
Anweisung Erase löscht die Werte aller Elemente eines Arrays, gibt allerdings normalerweise keinen Speicher frei. Um den Speicher freizumachen (bei großen Arrays wichtig !) führt man Redim b (0) aus.
Dim b() As Double
Redim b(100)

Erase b
Redim b(0)

♣ Tipp: Im Kapitel → Push() & Pop() auf dieser Seite wird gezeigt, wie man die Dimension eines Arrays ändert und dabei dessen Daten bewahrt.

Eigenschaften von VBA-Arrays

Funktion IsArray

liefert True, wenn das Argument ein Array ist, für alle anderen Variablen False. Das Beispiel demonstriert die Anwendung für eine 'gewöhnliche' (skalare) Variable und ein Array.
Dim i, j(10)
MsgBox "IsArray(i)=" & IsArray(i)
MsgBox "IsArray(j)=" & IsArray(j)

Funktionen LBound und UBound

Diese beiden Funktionen geben den minimalen und den maximalen Index eines Array an. Damit lässt sich die Länge (Anzahl der Elemente) berechnen.
Das Beispiel gibt als Index-Untergrenze (0) und als Obergrenze (10) aus.
Zur dynamischen Änderung der Array-Länge verwenden sie die Redim-Anweisung (s. oben).
MsgBox "LBound(j)=" & LBound(j)
MsgBox "LBound(j)=" & LBound(j)
MsgBox "Length=" & UBound(j) - LBound(j)

Funktion TypeName

liefert einen String mit der Type einer Variablen oder eines Arrays, z.B. "Integer" oder "String".
MsgBox "TypeName(j)=" & TypeName(j)

Lesen & Schreiben von Array-Elementen
Beim Lesen von Array-Elementen wird der Index in runde () Klammern gesetzt. Als Index kann eine ganze Zahl oder eine Variable vom Typ Integer verwendet werden.
z = x(3)
i = 123
z = x(i)
Das Schreiben von Array-Elementen erfolgt genau analog wie das Lesen.
p(5) = 3.1415
i = 15
p(i) = 4 * Atn(1)

Schleifen & Arrays
Eine Schleife (loop) ist die häufigste Methode zur Verarbeitung von Arrays.
Das Beispiel zeigt eine typische Initialisierung, d.h. das Schreiben von Anfangswerten in jedes Array-Element.
Beachten sie die Funktionen LBound und UBound (s.oben), mit denen man die Länge eines Arrays feststellen kann.
Die For-Next-Schleife ist praktisch, da der Schleifen-Zähler (hier i ) gleichzeitig als Array-Index dienen kann.
♦ Details zur Programmierung von Schleifen in VBA
Dim i As Integer
Dim z(1000) As Double
For i = 0 To 1000
z(i) = i * i
Next i
Eine besondere Variante ist die For-Each-Next-Schleife: Sie verwendet keinen (!) Index, sondern kopiert in jedem Durchgang ein Element des Arrays (hier z ) an die Schleifen-Variable (hier d ) vom gleichen Typ wie das Array.
Vorsicht: Man kann die Schleifen-Variable zwar lesen und fehlerfrei verarbeiten, eine Änderung dieser Variablen wirkt sich jedoch nicht auf die Array-Elemente aus !
Dim d, z(10) As Double
For Each d In z
MsgBox "d=" & d
d = d + 1 ' Readonly !
Next

Datei I/O und Arrays

Natürlich kann man Arrays so wie andere Variable beim Lesen und Schreiben von Dateien verwenden - in diesem Fall meist in Schleifen.
● Wesentlich schneller ist es jedoch, die Funktionen Put und Get ohne Schleife zu verwenden, so wie im Beispiel gezeigt: Das Array a wird mit einer einzigen Get oder Put-Anweisung gelesen bzw. geschrieben.
♦ Details zum Lesen und Schreiben von Dateien mit VBA.
Dim a(1000), fh As Integer
fh = FreeFile
Open "C:\test.dat" For Binary As fh
Put #fh, , a
Close fh

Mehrdimensionale Arrays
VBA-Arrays können in mehreren Dimensionen definiert werden. In solchen Fällen wird ein Array-Element nicht durch einen einzigen Index, sondern durch mehrere Indices adressiert.
Das Beispiel zeigt, wie ein 2dimensionales Array deklariert, gelesen und geschrieben wird.
Derzeit sind in VBA bis zu 60 Dimensionen möglich, weit mehr als normalerweise notwendig.
Dim d(25,25), r as Double
d(10,12) = 12.34
r = d(15,3)
Jeder einzelne Index wird ohne besondere Vereinbarung ab 0 (Null) gezählt. Das Beispiel zeigt, wie man jeden Index auch in einem anderen Bereich definieren kann.
Dim e(10 To 20, 100 To 200)
Häufig werden Bereiche von Kalkulations-Zellen in 2dimensionalen Arrays abgebildet. Man verwendet je einen Index für Zeilen und Spalten. Auch das VBA-Element Cells() wird wie ein 2dimensionales Array behandelt.

Das Beispiel ermittelt zunächst die Anzahl Zeilen (imax) und Spalten (jmax) des benannten Bereichs "myname". Dann werden 2 verschachtelte Schleifen durchlaufen, wobei Index i die Zeile, Index j die Spalte bezeichnet. Jede einzelne Zelle Cells() des Bereichs wird adressiert und ihr Wert Value eingetragen.

Verschachtelte Schleifen sind typisch für die Verarbeitung mehrdimensionaler Arrays.
Sub range_test()
Dim i, imax, j, jmax As Integer
Dim r As Range
Set r = Range("myname")
imax = r.Rows.Count
jmax = r.Columns.Count
For i = 1 To imax
For j = 1 To jmax
r.Cells(i, j).Value = 10 * i + j
Next j
Next i
End Sub

VBA-Array ↔ Kalkulations-Bereich
Zur Darstellung, Eingabe und Ausgabe von VBA-Arrays wird meistens ein Bereich von Kalkulations-Zellen verwendet, z.B. A1:A10 Dieses Kapitel zeigt, wie man den Inhalt eines Bereichs in ein VBA-Array überträgt und umgekehrt.

Bereichs-Namen:

Jeder Bereich von Kalkulations-Zellen lässt sich iin der Form A1:C3 angeben. Das ist jedoch sehr empfindlich und in VBA nicht empfehlenswert:
● Wenn der Bereich auf dem Arbeitsblatt verändert (verschoben) wird, dann werden zwar alle mit dem Bereich verknüpften Kalkulations-Formeln angepasst, nicht jedoch die in VBA-Programmen verwendeten Bereichs-Adressen !
● Verwenden sie daher in VBA ausschließlich Bereiche, für die ein Name (hier myname ) vergeben wurde - Diese Methode berücksichtigt jede Verschiebung.

Kalkulations-Bereich → Array

Das Beispiel rechts zeigt, wie man einen benannten Bereich von Zellen (OpenOffice-Calc, MS-Excel, ... - hier der Bereich myname ) in ein VBA-Array einlesen kann.

Im Beispiel wird das Array z zunächst passend zur Größe des Bereichs dimensioniert. Danach werden die Werte aller Zellen des Bereichs zeilenweise in das Array eingelesen.
Leider werden die Zellen eines Bereichs nicht konsequent nummeriert: Die erste Zelle erhält nicht Index (0) sondern Index (1) !
Sub range_to_array()
Dim i As Integer
Dim z() As Double
Dim r As Range
Set r = Range("myname")
ReDim z(r.Count)
For i = 1 To r.Count
z(i) = r.Cells(i).Value
'MsgBox "z(" & i & ")=" & z(i)
Next i
End Sub

Array → Kalkulations-Bereich

Das Beispiel zeigt, wie man die Daten eines VBA-Arrays in einen Bereich von Kalkulations-Zellen schreiben kann.
Das Array z wird zur Demonstration mit fortlaufenden ganzen Zahlen gefüllt.
Danach werden so viele Zahlen in den benannten Bereich "myname" eingetragen, wie seiner Größe entspricht. Die Eintragung erfolgt zeilenweise, die erste Zelle des Bereichs erhält Index (1).
Sub array_to_range()
Dim i, j As Integer
Dim z(1000) As Double
Dim r As Range
For i = 0 To 1000
z(i) = i
Next i
Set r = Range("myname")
j = r.Count
If j > 1000 Then j = 1000
For i = 1 To j
r.Cells(i).Value = z(i)
Next i
End Sub

Übergabe von Arrays an Unterprogramme
Es ist möglich, Arrays an VBA-Unterprogramme ( Function oder Sub ) zu übergeben. Die Übergabe kann jedoch nur nach der Methode ByRef erfolgen, nicht nach ByVal. Das bedeutet, dass nicht die Werte des Arrays an das aufgerufene Programm übergeben werden, sondern seine Adresse. Das geht natürlich weitaus schneller.

Daher verhalten sich Arrays, die als Argumente übergeben wurden, nicht wie andere Variable der Argumente-Liste. Der Variablen-Name ist zwar lokal derfiniert, die Wirkung jedoch global ! Anders ausgedrückt: Jede Änderung eines Array-Elements in einem Unterprogramm ändert das Element auch im Array des aufrufenden Programms !

Im Beispiel wird im Sub subtest1 ein lokales Array a definiert und mit den Zahlen (1,2,3) gefüllt. Das Array a wird als Argument an das aufgerufene Sub subtest2 übergeben.
In subtest2 wird das Array unter dem Namen b geführt, ist jedoch identisch (!) mit Array a des aufrufenden Programms. Alle Elemente von b werden mit 10 multipliziert. Nach dem Ende von subtest2 wird die Kontrolle wieder an subtest1 übergeben - Dort hat Array a nun die Werte (10,20,30).
Sub subtest1()
Dim a(3), i As Integer
For i = 1 To 3
a(i) = i
Next i
Call subtest2(a)
End Sub

Sub subtest2(b)
Dim m As Integer
For m = LBound(b) To UBound(b)
b(m) = b(m) * 10
Next m
End Sub
Wenn man unbedingt eine Kopie an ein Unterprogramm übergeben will, dann muss man diese selbst anfertigen. Das ist nicht schwierig, kann jedoch bei großen Arrays einen hohen Aufwand an Speicherplatz und Prozessor-Zeit erfordern.
Die Übergabe von Arrays als Argumente kann auch als Trick verwendet werden, um Arrays von einem Unterprogramm an das aufrufende Programm zu übergeben. Sehen sie dazu das nächste Kapitel.

Rückgabe von Arrays aus Unterprogrammen
Die Rückgabe von Arrays an ein aufrufendes Programm ist offenbar in VBA nicht vorgesehen. Man kann dieses Problem durch verschiedene Tricks umgehen.

Globale Arrays

Wenn ein Array global definiert wird (siehe oben), dann haben alle Functions und Subs eines Moduls darauf Zugriff. 		In diesem Fall entfällt sowohl die Übergabe des Arrays vom aufrufenden Programm an das Unterprogramm, als auch umgekehrt die Rückgabe des Arrays an das aufrufende Programm.

Übergabe als Argument

Man kann ein Array als Argument an ein Unterprogramm übergeben, und diese Möglichkeit dazu ausnützen, um Daten in die umgekehrte Richtung zu übergeben.
Ohne ausdrückliche Rückgabe stehen die geänderten Daten anschließend im aufrufenden Programm zur Verfügung.

Im Beispiel wird Array a nur formal als Argument an subtest4 übergeben. Tatsächlich wird nur die Adresse eines leeren Arrays übergeben. Die eigentliche Arbeit wird in subtest4 ausgeführt. Nach dem Ende von subtest4 stehen jedoch alle Array-Daten im aufrufenden Programm subtest3 zur Verfügung (hier die Zahlen 1,4,9,16,25) - Genauso, wie wenn das Array als Funktionswert zurückgegeben worden wäre.
Sub subtest3()
Dim a() As Integer
Call subtest4(a)
End Sub

Sub subtest4(b)
Dim m As Integer
ReDim b(5)
For m = 1 To 5
b(m) = m * m
Next m
End Sub

Übergabe an das Kalkulations-Programm

Die Übergabe der Elemente eines VBA-Arrays an das Kalkulations-Programm (OpenOffice-Calc, MS-Excel) ist mühsam: Man kann das Ergebnis nur in 1 Zelle eintragen, und muss daher jedes Array-Element einzeln adressieren (hier mit dem Argument index).

Beispiel:
Die Kalkulations-Formel =wd_demo(3) liefert mit "Do" das 3.Element von Array wdn (die Zählung der Elemente beginnt mit 0).

Dieses Beispiel funktioniert in jedem allgemeinen Fall. Wenn die Dimension des Arrays bekannt und gleichbleibend ist, verwendet man besser eine Schleife, welche alle Array-Elemente in einen benannten Bereich einträgt.
Function wd_demo(index As Integer) As String
Dim wdn() As Variant
wda = Array("Mo", "Di", "Mi", "Do", "Fr", "Sa", "So")
If index >= LBound(wda) And index <= UBound(wda) Then
wd_demo = wda(index)
Else
wd_demo = "???"
End If
End Function

Verweise (Lookup)
Ein Verweis stellt anschaulich eine Beziehung zwischen 2 Spalten einer Tabelle her:
Man kennt das Element einer Spalte und findet damit das korrespondiernde Element in der anderen Spalte. 		Jede Tabellen-Kalkulation bietet dazu die Funktion LOOKUP (deutsch VERWEIS) in mehreren Varianten.

Funktion Choose

Diese Funktion bietet eine einfache und rasche Alternative, wenn eine Spalte aus fortlaufenden ganzen Zahlen (Index) gebildet wird.
Als 1. Argument dient eine ganze Zahl, die als Index für die anschließend gelisteten Elemente dient. Das Beispiel rechts gibt den aktuellen Wochentag zurück.
Function pst_current_weekday() _
As String
Dim wdnr As Integer
wdnr = Weekday(Now, 2)
pst_current_weekday = Choose(wdnr, "Mo", "Di", "Mi", "Do", "Fr", "Sa", "So")
End Function

Stack-Funktionen: Push() und Pop()
VBA bietet keine Standard-Funktionen für die Verwendung von Arrays als Datenspeicher der Type Stack (Stapel) Hier wird vorgestellt, wie man diese Funktionen ersetzen kann.
Die hier gezeigten Beispiele verwenden Arrays der Type String zur Simulation eines Stack-Speichers

Das Muster rechts zeigt, wie man den Stack verwenden kann:
• Mit array_string_pop() wird das letzte Element aus dem Array entnommen und als Ergebnis der Funktion zurückgegeben.

• Mit array_string_push() wird ein neues Element an das Array angefügt. Die Funktion gibt die neue Obergrenze ( UBound ) als ganze Zahl zurück.

Beide Funktionen entsprechen nicht ganz jenen der modernen Programmiersprachen:
• Wenn das Array nur 1 Element hat, dann wird mit array_string_pop() lediglich dessen Inhalt gelöscht, nicht das Element selbst. Das Element bleibt als leerer String erhalten.
• Umgekehrt wird mit array_string_push() der neu einzutragende String in das 1. Element eingetragen, wenn es nur dieses Element gibt und wenn es einen leeren String enthält. 		Visual Basic (VBA) Beispiel zur Anwendung der Stack-Funktionen:
Dim i As Integer
Dim s, sa() As String
ReDim sa(4)
For i = 0 To 2
sa(i) = Chr(i + 65)
Next
ergibt das Array sa mit den Elementen
"A","B","C"
Abtragen des Stacks mit
s = array_string_pop(sa)
ergibt das abgetragene Element s="A" und das kürzere (!) Array
"A","B"
Aufschichten des Stacks mit
i=array_string_push(sa,"zzz")
ergibt die neue Obergrenze i=2 und das längere (!) Array
"A","B","zzz"
Die Funktion erhält das Array a (genauer: einen Pointer auf das Array) als Argument

Die Verkürzung eines Arrays ist jedoch nicht trivial.
Der maximale Index des Arrays wird mit Funktion UBound() ermittelt und in der Variablen iub gespeichert. Wenn das Array keine Elemente enthält, dann tritt dabei ein Fehler auf.

Der Wert des letzten Elements a(iub) wird an die Variable a0 zugewiesen und mit dieser am Ende der Funktion zurückgegeben.

Das Array b wird als Zwischenspeicher dimensioniert. Alle Daten mit Ausnahme des letzten Elements von a nach b kopiert.
Das Original-Array a wird neu dimensioniert.
Zuletzt werden die Daten aus dem Zwischenspeicher b in das (nun verkürzte) Array a kopiert.

• Sonderfall: Wenn das letzte Element entnommen wurde, dann wird das Array a gelöscht.

• Sonderfall: Wenn das Array keine Elemente (mehr) enthält, dann wird in dieser Version ein leerer String zurückgegeben. 		Diese Visual Basic (VBA) Funktion schichtet das letzte Element eines Stack-Arrays ab:
Function array_string_pop(a) As String
Dim i, iub As Integer
Dim a0, b() As String
On Error GoTo aspe
iub = UBound(a)
a0 = a(iub)
If iub > 0 Then
ReDim b(iub - 1)
For i = 0 To iub - 1
b(i) = a(i)
Next
ReDim a(iub - 1)
For i = 0 To iub - 1
a(i) = b(i)
Next
Else
Erase a
End If
array_string_pop = a0
Exit Function
aspe:
array_string_pop = ""
End Function
Die Funktion erhält als Argumente das Array a (genauer: einen Pointer auf das Array) und das neu aufzuschichtende Element anew

Der maximale Index des Arrays wird mit Funktion UBound() ermittelt und in der Variablen iub gespeichert.
Das Array b wird als Zwischenspeicher dimensioniert, und das neue Element mit dem Wert anew eingetragen.
Danach werden alle Daten von a nach b kopiert, allerdings um eine Index-Position nach 'oben' versetzt.
Das Original-Array a wird neu dimensioniert.
Zuletzt werden die Daten aus dem Zwischenspeicher b in das (nun verlängerte) Array a kopiert.

• Sonderfall: Wenn das erhaltene Array a nur 1 Element enthält, und wenn dieses einen leeren String enthält, dann wird kein neues Element erzeugt, sondern die Daten anew in das erste Element übertragen. Diese Programm-Teil ist nicht notwendig, sondern wurde eingeführt, um die Symmetrie zur ↑ Funktion array_string_pop() herzustellen. 		Diese Visual Basic (VBA) Funktion schichtet ein neues Element auf ein Stack-Array:
Function array_string_push(a, anew As String) As Integer
Dim i, iub As Integer
Dim b() As String
On Error GoTo aspe
iub = UBound(a)
ReDim b(iub + 1)
For i = 0 To iub
b(i) = a(i)
Next
b(iub + 1) = anew
ReDim a(iub + 1)
For i = 0 To iub + 1
a(i) = b(i)
Next
array_string_push = iub + 1
Exit Function
aspe:
ReDim a(0)
a(0) = anew
array_string_push = 0
End Function

Strukturierte Texte und Arrays:   Split() & Join()
In der Informatik trifft man gelegentlich auf strukturierte Texte jener Art, bei welcher einer unterschiedliche Anzahl von Einzelteilen durch spezielle Trennzeichen getrennt bzw. verbunden ist.
Typische Beispiele sind Web-Adressen, IP-Adressen, Datei-Pfade, ... 		Eine eigene Seite stellt VBA-Funktionen zu diesem Thema vor, die sowohl mit Kalkulations-Programmen (LibreOffice, OpenOffice, MS-Excel, ...) als auch mit VBA verwendbar sind. Spezielle Beispiele: Spalten und Zusammenfügen von 'Sätzen' (aus Worten), IP-Adressen, Datei-Pfaden, Internet-Adressen, Datum & Zeit, usw.
♦ Details zu Split() und Join()

Funktion Join()

verknüpft ein Array der Type String (im Beispiel sa) zu einem einzelnen String.
Diese Funktion eignet sich zum Aufbau systematisch strukturierter Strings.

Die Beispiel-Funktion kann man in jedem Kalkulations-Programm (LibreOffice, OpenOffice, MS-Excel, ...) verwenden. Der Inhalt der mit bereich angegebenen Zellen wird mit dem als join_char bezeichneten Zeichen zu einem Text verknüpft.

Beispiel:
Die Zellen A1..C1 enthalten die Texte a,b,c
Die Formel =pst_join(A1:C1;"#") ergibt "a#b#c"
Function pst_join( _
bereich As Range, _
Optional join_char As String = "") As String
Dim i, imax As Integer
Dim sa() As String
imax = bereich.Count
ReDim sa(imax - 1)
For i = 1 To imax
sa(i - 1) = bereich(i).Value
Next
pst_join = Join(sa, join_char)
End Function

Funktion Split()

zerlegt einen systematisch strukturierten String in ein Array der Type String
Ein String (hier s ) wird an allen Stellen zerlegt, die einen 'Delimiter'-String (Trennzeichen, z.B. das Zeichen "#") enthalten. Dabei werden alle Trennzeichen entfernt.

Die Beispiel-Funktion kann man in jedem Kalkulations-Programm (OpenOffice Calc, MS-Excel, ...) verwenden, um ein einzelnes Element eines strukturierten Strings zu isolieren.

Beispiel:
Zelle A2 enthält den Text a#b#c
Die Formel =pst_split(A2;"#";2) gibt das 2.Element "b" zurück.
Function pst_split( _
text As String, _
separator As String, _
index As Integer) As String
Dim sa() As String
If index <= 0 Or index > 100 Then
pst_split = text
Else
sa = Split(text, separator)
pst_split = sa(index - 1)
End If
End Function

Ausgewählte Links zum Thema 'VBA @ Array'

  ● Visual Basic 2005 Handbuch (Andreas Kühnel / Galileo) - Grundlagen der Sprach-Syntax / Arrays, .NET-Arrays

Zum Inhaltsverzeichnis Homepage von PS-Trainer   >   Entwicklung   >   VBA   >   Array