VBA
Arrays

Ein Array in VBA deklarieren

Das Deklarieren eines Arrays ist dem Deklarieren einer Variablen sehr ähnlich, mit der Ausnahme, dass Sie die Dimension des Arrays direkt nach seinem Namen deklarieren müssen:

Dim myArray(9) As String 'Declaring an array that will contain up to 10 strings

Standardmäßig werden Arrays in VBA von NULL indiziert. Daher bezieht sich die Zahl in Klammern nicht auf die Größe des Arrays, sondern auf den Index des letzten Elements

Zugriff auf Elemente

Der Zugriff auf ein Element des Arrays erfolgt über den Namen des Arrays, gefolgt vom Index des Elements in Klammern:

myArray(0) = "first element"
myArray(5) = "sixth element"
myArray(9) = "last element"

Array-Indizierung

Sie können die Indizierung der Arrays ändern, indem Sie diese Zeile oben in einem Modul platzieren:

Option Base 1

Mit dieser Zeile werden alle im Modul deklarierten Arrays von ONE indiziert .

Spezifischer Index

Sie können jedes Array auch mit seinem eigenen Index deklarieren, indem Sie das To Schlüsselwort und die Unter- und Obergrenze (= Index) verwenden:

Dim mySecondArray(1 To 12) As String 'Array of 12 strings indexed from 1 to 12
Dim myThirdArray(13 To 24) As String 'Array of 12 strings indexed from 13 to 24

Dynamische Deklaration

Wenn Sie die Größe Ihres Arrays vor der Deklaration nicht kennen, können Sie die dynamische Deklaration und das Schlüsselwort ReDim :

Dim myDynamicArray() As Strings 'Creates an Array of an unknown number of strings
ReDim myDynamicArray(5) 'This resets the array to 6 elements

Beachten Sie, dass mit dem Schlüsselwort ReDim alle vorherigen Inhalte Ihres Arrays ReDim werden. Um dies zu verhindern, können Sie nach ReDim das Schlüsselwort Preserve ReDim :

Dim myDynamicArray(5) As String
myDynamicArray(0) = "Something I want to keep"

ReDim Preserve myDynamicArray(8) 'Expand the size to up to 9 strings
Debug.Print myDynamicArray(0) ' still prints the element

Verwendung von Split zum Erstellen eines Arrays aus einer Zeichenfolge

Split-Funktion

Gibt ein nullbasiertes, eindimensionales Array zurück, das eine angegebene Anzahl von Teilzeichenfolgen enthält.

Syntax

Split (Ausdruck [, Trennzeichen [, Limit [, vergleichen ]]] )

die Einstellungen

Das Compare- Argument kann folgende Werte annehmen:

Beispiel

In diesem Beispiel wird gezeigt, wie Split durch das Anzeigen mehrerer Stile funktioniert. In den Kommentaren wird die Ergebnismenge für die verschiedenen durchgeführten Split-Optionen angezeigt. Schließlich wird gezeigt, wie das zurückgegebene String-Array durchlaufen wird.

Sub Test
    
    Dim textArray() as String

    textArray = Split("Tech on the Net")
    'Result: {"Tech", "on", "the", "Net"}

    textArray = Split("172.23.56.4", ".")
    'Result: {"172", "23", "56", "4"}

    textArray = Split("A;B;C;D", ";")
    'Result: {"A", "B", "C", "D"}

    textArray = Split("A;B;C;D", ";", 1)
    'Result: {"A;B;C;D"}

    textArray = Split("A;B;C;D", ";", 2)
    'Result: {"A", "B;C;D"}

    textArray = Split("A;B;C;D", ";", 3)
    'Result: {"A", "B", "C;D"}

    textArray = Split("A;B;C;D", ";", 4)
    'Result: {"A", "B", "C", "D"}

    'You can iterate over the created array
    Dim counter As Long

    For counter = LBound(textArray) To UBound(textArray)
        Debug.Print textArray(counter)
    Next
 End Sub

Elemente eines Arrays iterieren

Fürs nächste

Die Iterator-Variable als Indexnummer ist der schnellste Weg, um die Elemente eines Arrays zu iterieren:

Dim items As Variant
items = Array(0, 1, 2, 3)

Dim index As Integer
For index = LBound(items) To UBound(items)
    'assumes value can be implicitly converted to a String:
    Debug.Print items(index) 
Next

Verschachtelte Schleifen können verwendet werden, um mehrdimensionale Arrays zu iterieren:

Dim items(0 To 1, 0 To 1) As Integer
items(0, 0) = 0
items(0, 1) = 1
items(1, 0) = 2
items(1, 1) = 3

Dim outer As Integer
Dim inner As Integer
For outer = LBound(items, 1) To UBound(items, 1)
    For inner = LBound(items, 2) To UBound(items, 2)
        'assumes value can be implicitly converted to a String:
        Debug.Print items(outer, inner)
    Next
Next

Für jeden ... Weiter

A For Each...Next Schleife kann auch zum Durchlaufen von Arrays verwendet werden, wenn die Leistung keine Rolle spielt:

Dim items As Variant
items = Array(0, 1, 2, 3)

Dim item As Variant 'must be variant
For Each item In items
    'assumes value can be implicitly converted to a String:
    Debug.Print item
Next

A For Each Schleife durchläuft alle Dimensionen von außen nach innen (die Reihenfolge, in der die Elemente im Speicher angeordnet sind), sodass keine geschachtelten Schleifen erforderlich sind:

Dim items(0 To 1, 0 To 1) As Integer
items(0, 0) = 0
items(1, 0) = 1
items(0, 1) = 2
items(1, 1) = 3

Dim item As Variant 'must be Variant
For Each item In items
    'assumes value can be implicitly converted to a String:
    Debug.Print item
Next

Beachten Sie, dass For Each Schleifen am besten zum Durchlaufen von Collection Objekten verwendet werden, wenn die Leistung von Bedeutung ist.

Alle 4 Ausschnitte oben erzeugen die gleiche Ausgabe:

 0
 1
 2
 3

Dynamische Arrays (Größenanpassung von Arrays und dynamisches Handling)

Dynamische Arrays

Das dynamische Hinzufügen und Reduzieren von Variablen in einem Array ist ein großer Vorteil, wenn die von Ihnen behandelten Informationen nicht über eine bestimmte Anzahl von Variablen verfügen.

Werte dynamisch hinzufügen

Sie können das Array einfach mit der ReDim Anweisung in der Größe ändern. ReDim wird das Array jedoch verkleinert. Wenn Sie jedoch die Informationen beibehalten ReDim , die bereits im Array gespeichert sind, benötigen Sie den Teil Preserve .

Im folgenden Beispiel erstellen wir ein Array und erhöhen es in jeder Iteration um eine weitere Variable, während die Werte, die sich bereits im Array befinden, beibehalten werden.

Dim Dynamic_array As Variant
' first we set Dynamic_array as variant

For n = 1 To 100

    If IsEmpty(Dynamic_array) Then
        'isempty() will check if we need to add the first value to the array or subsequent ones
    
        ReDim Dynamic_array(0)
        'ReDim Dynamic_array(0) will resize the array to one variable only
        Dynamic_array(0) = n

    Else
        ReDim Preserve Dynamic_array(0 To UBound(Dynamic_array) + 1)
        'in the line above we resize the array from variable 0 to the UBound() = last variable, plus one effectivelly increeasing the size of the array by one
        Dynamic_array(UBound(Dynamic_array)) = n
        'attribute a value to the last variable of Dynamic_array
    End If

Next

Werte dynamisch entfernen

Wir können dieselbe Logik verwenden, um das Array zu verkleinern. Im Beispiel wird der Wert "last" aus dem Array entfernt.

Dim Dynamic_array As Variant
Dynamic_array = Array("first", "middle", "last")
    
ReDim Preserve Dynamic_array(0 To UBound(Dynamic_array) - 1)
' Resize Preserve while dropping the last value

Array zurücksetzen und dynamisch wiederverwenden

Wir können die von uns erstellten Arrays genauso gut wiederverwenden, als nicht viele im Speicher vorhanden sind, was die Laufzeit verlangsamen würde. Dies ist nützlich für Arrays verschiedener Größen. Ein Ausschnitt, den Sie zur erneuten Verwendung des Arrays verwenden könnten, besteht ReDim das Array wieder auf (0) zu ReDim dem Array eine Variable zuzuordnen und das Array frei zu vergrößern.

In dem folgenden Snippet konstruiere ich ein Array mit den Werten 1 bis 40, leeren Sie das Array und füllen Sie das Array mit den Werten 40 bis 100 auf. Dies geschieht alles dynamisch.

Dim Dynamic_array As Variant

For n = 1 To 100

    If IsEmpty(Dynamic_array) Then
        ReDim Dynamic_array(0)
        Dynamic_array(0) = n
    
    ElseIf Dynamic_array(0) = "" Then
        'if first variant is empty ( = "") then give it the value of n
        Dynamic_array(0) = n
    Else
        ReDim Preserve Dynamic_array(0 To UBound(Dynamic_array) + 1)
        Dynamic_array(UBound(Dynamic_array)) = n
    End If
    If n = 40 Then
        ReDim Dynamic_array(0)
        'Resizing the array back to one variable without Preserving,
        'leaving the first value of the array empty
    End If

Next

Gezackte Arrays (Arrays von Arrays)

Gezackte Arrays NICHT multidimensionale Arrays

Arrays von Arrays (gezackte Arrays) sind nicht identisch mit mehrdimensionalen Arrays, wenn Sie visuell darüber nachdenken. Multidimensionale Arrays sehen wie Matrizen (rechteckig) mit einer definierten Anzahl von Elementen auf ihren Dimensionen (innerhalb von Arrays) aus, während ein Jagged-Array wie ein Jahr aussehen würde Kalender, wobei die inneren Arrays eine unterschiedliche Anzahl von Elementen aufweisen, z. B. Tage in verschiedenen Monaten.

Obwohl Jagged Arrays aufgrund ihrer verschachtelten Ebenen recht unübersichtlich und schwierig zu verwenden sind, bieten sie nicht viel Sicherheit. Sie sind jedoch sehr flexibel und ermöglichen es Ihnen, verschiedene Datentypen auf einfache Weise zu manipulieren und müssen nicht verwendet werden leere Elemente.

Erstellen eines gezackten Arrays

Im folgenden Beispiel werden wir ein gezacktes Array initialisieren, das zwei Arrays enthält, eines für Names und eines für Numbers, und dann auf ein Element von jedem zugreifen

Dim OuterArray() As Variant
Dim Names() As Variant
Dim Numbers() As Variant
'arrays are declared variant so we can access attribute any data type to its elements

Names = Array("Person1", "Person2", "Person3")
Numbers = Array("001", "002", "003")

OuterArray = Array(Names, Numbers)
'Directly giving OuterArray an array containing both Names and Numbers arrays inside

Debug.Print OuterArray(0)(1)
Debug.Print OuterArray(1)(1)
'accessing elements inside the jagged by giving the coordenades of the element

Gepackte Arrays dynamisch erstellen und lesen

Wir können auch dynamischer sein, um die Arrays zu erstellen, stellen wir uns vor, wir haben ein Kundendatenblatt in Excel und wir möchten ein Array erstellen, um die Kundendaten auszugeben.

   Name -   Phone   -  Email  - Customer Number 
Person1 - 153486231 - 1@STACK - 001
Person2 - 153486242 - 2@STACK - 002
Person3 - 153486253 - 3@STACK - 003
Person4 - 153486264 - 4@STACK - 004
Person5 - 153486275 - 5@STACK - 005

Wir werden dynamisch ein Header-Array und ein Customers-Array erstellen, der Header enthält die Spaltentitel und das Customers-Array enthält die Informationen der einzelnen Kunden / Zeilen als Arrays.

Dim Headers As Variant
' headers array with the top section of the customer data sheet
    For c = 1 To 4
        If IsEmpty(Headers) Then
            ReDim Headers(0)
            Headers(0) = Cells(1, c).Value
        Else
            ReDim Preserve Headers(0 To UBound(Headers) + 1)
            Headers(UBound(Headers)) = Cells(1, c).Value
        End If
    Next
    
Dim Customers As Variant
'Customers array will contain arrays of customer values
Dim Customer_Values As Variant
'Customer_Values will be an array of the customer in its elements (Name-Phone-Email-CustNum)
    
    For r = 2 To 6
    'iterate through the customers/rows
        For c = 1 To 4
        'iterate through the values/columns
            
            'build array containing customer values
            If IsEmpty(Customer_Values) Then
                ReDim Customer_Values(0)
                Customer_Values(0) = Cells(r, c).Value
            ElseIf Customer_Values(0) = "" Then
                Customer_Values(0) = Cells(r, c).Value
            Else
                ReDim Preserve Customer_Values(0 To UBound(Customer_Values) + 1)
                Customer_Values(UBound(Customer_Values)) = Cells(r, c).Value
            End If
        Next
        
        'add customer_values array to Customers Array
        If IsEmpty(Customers) Then
            ReDim Customers(0)
            Customers(0) = Customer_Values
        Else
            ReDim Preserve Customers(0 To UBound(Customers) + 1)
            Customers(UBound(Customers)) = Customer_Values
        End If
        
        'reset Custumer_Values to rebuild a new array if needed
        ReDim Customer_Values(0)
    Next

    Dim Main_Array(0 To 1) As Variant
    'main array will contain both the Headers and Customers
    
    Main_Array(0) = Headers
    Main_Array(1) = Customers

To better understand the way to Dynamically construct a one dimensional array please check Dynamic Arrays (Array Resizing and Dynamic Handling) on the Arrays documentation.

Das Ergebnis des obigen Snippets ist ein Jagged-Array mit zwei Arrays, eines dieser Arrays mit 4 Elementen, 2 Eindrückungsstufen und das andere selbst, ein weiteres Jagged-Array, das 5 Arrays mit jeweils 4 Elementen und 3 Eindrückungsstufen enthält. Siehe folgende Struktur:

Main_Array(0) - Headers - Array("Name","Phone","Email","Customer Number")
          (1) - Customers(0) - Array("Person1",153486231,"1@STACK",001)
                Customers(1) - Array("Person2",153486242,"2@STACK",002)
                ...
                Customers(4) - Array("Person5",153486275,"5@STACK",005)

Um auf die Informationen zuzugreifen, müssen Sie die Struktur des von Ihnen erstellten Jagged-Arrays berücksichtigen. Im obigen Beispiel sehen Sie, dass das Main Array ein Array von Headers und ein Array von Arrays ( Customers ) enthält, mit unterschiedlichen Möglichkeiten Zugriff auf die Elemente.

Nun lesen wir die Informationen des Main Array und drucken jede Kundeninformation als Info Type: Info .

For n = 0 To UBound(Main_Array(1))
    'n to iterate from fisrt to last array in Main_Array(1)
    
    For j = 0 To UBound(Main_Array(1)(n))
        'j will iterate from first to last element in each array of Main_Array(1)
        
        Debug.Print Main_Array(0)(j) & ": " & Main_Array(1)(n)(j)
        'print Main_Array(0)(j) which is the header and Main_Array(0)(n)(j) which is the element in the customer array
        'we can call the header with j as the header array has the same structure as the customer array
    Next
Next

Denken Sie daran, die Struktur Ihres Jagged-Arrays zu verfolgen. In dem Beispiel oben, um auf den Namen eines Kunden zuzugreifen, Main_Array -> Customers -> CustomerNumber -> Name der aus drei Ebenen besteht, um "Person4" die Position der Kunden im Main_Array, dann die Position des Kunden vier im Arrays Customers Jagged und zuletzt die Position des benötigten Elements, in diesem Fall Main_Array(1)(3)(0) wobei es sich um Main_Array(Customers)(CustomerNumber)(Name) .

Mehrdimensionale Arrays

Mehrdimensionale Arrays

Wie der Name schon sagt, sind mehrdimensionale Arrays Arrays, die mehr als eine Dimension enthalten, normalerweise zwei oder drei, aber sie können bis zu 32 Dimensionen haben.

Ein Multi-Array arbeitet wie eine Matrix mit verschiedenen Ebenen, nehmen Sie zum Beispiel einen Vergleich zwischen einer, zwei und drei Dimensionen.

Eine Dimension ist Ihr typisches Array, es sieht aus wie eine Liste von Elementen.

Dim 1D(3) as Variant

*1D - Visually*
(0)
(1)
(2)

Zwei Dimensionen würden wie ein Sudoku-Grid oder eine Excel-Tabelle aussehen. Beim Initialisieren des Arrays würden Sie festlegen, wie viele Zeilen und Spalten das Array enthalten würde.

Dim 2D(3,3) as Variant
'this would result in a 3x3 grid 

*2D - Visually*
(0,0) (0,1) (0,2)
(1,0) (1,1) (1,2)
(2,0) (2,1) (2,2)

Drei Dimensionen würden wie Rubiks Würfel aussehen. Beim Initialisieren des Arrays würden Sie Zeilen und Spalten und Layer / Tiefen definieren, die das Array hätte.

Dim 3D(3,3,2) as Variant
'this would result in a 3x3x3 grid

*3D - Visually*
       1st layer                 2nd layer                  3rd layer
         front                     middle                     back
(0,0,0) (0,0,1) (0,0,2) ¦ (1,0,0) (1,0,1) (1,0,2) ¦ (2,0,0) (2,0,1) (2,0,2)
(0,1,0) (0,1,1) (0,1,2) ¦ (1,1,0) (1,1,1) (1,1,2) ¦ (2,1,0) (2,1,1) (2,1,2)
(0,2,0) (0,2,1) (0,2,2) ¦ (1,2,0) (1,2,1) (1,2,2) ¦ (2,2,0) (2,2,1) (2,2,2)

Weitere Dimensionen könnten als Multiplikation der 3D-Technik betrachtet werden, sodass eine 4D (1,3,3,3) zwei nebeneinander liegende 3D-Arrays sein würde.

Zwei-Dimension-Array

Erstellen

Im folgenden Beispiel wird eine Liste von Mitarbeitern zusammengestellt. Jeder Mitarbeiter verfügt über eine Reihe von Informationen (Vorname, Nachname, Adresse, E-Mail, Telefon ...). Das Beispiel wird im Wesentlichen im Array gespeichert ( Mitarbeiter, Information) (0,0) ist der Vorname des ersten Mitarbeiters.

Dim Bosses As Variant
'set bosses as Variant, so we can input any data type we want

Bosses = [{"Jonh","Snow","President";"Ygritte","Wild","Vice-President"}]
'initialise a 2D array directly by filling it with information, the redult wil be a array(1,2) size 2x3 = 6 elements

Dim Employees As Variant
'initialize your Employees array as variant
'initialize and ReDim the Employee array so it is a dynamic array instead of a static one, hence treated differently by the VBA Compiler
ReDim Employees(100, 5)
'declaring an 2D array that can store 100 employees with 6 elements of information each, but starts empty
'the array size is 101 x 6 and contains 606 elements

For employee = 0 To UBound(Employees, 1)
'for each employee/row in the array, UBound for 2D arrays, which will get the last element on the array
'needs two parameters 1st the array you which to check and 2nd the dimension, in this case 1 = employee and 2 = information
    For information_e = 0 To UBound(Employees, 2)
    'for each information element/column in the array
        
        Employees(employee, information_e) = InformationNeeded ' InformationNeeded would be the data to fill the array
        'iterating the full array will allow for direct attribution of information into the element coordinates
    Next
Next

Größenänderung

Größenänderung oder ReDim Preserve Wenn ReDim Preserve ein Multi-Array wie die Norm für ein One-Dimension-Array ReDim Preserve , wird ein Fehler ReDim Preserve Stattdessen müssen die Informationen in ein temporäres Array mit derselben Größe wie das Original plus der Anzahl der hinzuzufügenden Zeilen / Spalten übertragen werden. Im folgenden Beispiel sehen Sie, wie Sie ein Temp-Array initialisieren, die Informationen aus dem ursprünglichen Array übernehmen, die restlichen leeren Elemente füllen und das temporäre Array durch das ursprüngliche Array ersetzen.

Dim TempEmp As Variant
'initialise your temp array as variant
ReDim TempEmp(UBound(Employees, 1) + 1, UBound(Employees, 2))
'ReDim/Resize Temp array as a 2D array with size UBound(Employees)+1 = (last element in Employees 1st dimension) + 1,
'the 2nd dimension remains the same as the original array. we effectively add 1 row in the Employee array

'transfer
For emp = LBound(Employees, 1) To UBound(Employees, 1)
    For info = LBound(Employees, 2) To UBound(Employees, 2)
        'to transfer Employees into TempEmp we iterate both arrays and fill TempEmp with the corresponding element value in Employees
        TempEmp(emp, info) = Employees(emp, info)
    
    Next
Next

'fill remaining
'after the transfers the Temp array still has unused elements at the end, being that it was increased
'to fill the remaining elements iterate from the last "row" with values to the last row in the array
'in this case the last row in Temp will be the size of the Employees array rows + 1, as the last row of Employees array is already filled in the TempArray

For emp = UBound(Employees, 1) + 1 To UBound(TempEmp, 1)
    For info = LBound(TempEmp, 2) To UBound(TempEmp, 2)
        
        TempEmp(emp, info) = InformationNeeded & "NewRow"
    
    Next
Next

'erase Employees, attribute Temp array to Employees and erase Temp array
Erase Employees
Employees = TempEmp
Erase TempEmp

Elementwerte ändern

Zum Ändern / Ändern der Werte in einem bestimmten Element können Sie einfach die Koordinate aufrufen, die geändert werden soll, und einen neuen Wert Employees(0, 0) = "NewValue" : Employees(0, 0) = "NewValue"

Alternativ können Sie die Koordinaten verwenden, um die Werte entsprechend den erforderlichen Parametern abgleichen zu können:

For emp = 0 To UBound(Employees)
    If Employees(emp, 0) = "Gloria" And Employees(emp, 1) = "Stephan" Then
    'if value found
        Employees(emp, 1) = "Married, Last Name Change"
        Exit For
        'don't iterate through a full array unless necessary
    End If
Next

lesen

Der Zugriff auf die Elemente im Array kann mit einer geschachtelten Schleife (durchlaufen jedes Element), mit Schleife und Koordinate (durch wiederholte Zeilen und direktem Zugriff auf Spalten) oder direkt mit beiden Koordinaten erfolgen.

'nested loop, will iterate through all elements
For emp = LBound(Employees, 1) To UBound(Employees, 1)
    For info = LBound(Employees, 2) To UBound(Employees, 2)
        Debug.Print Employees(emp, info)
    Next
Next

'loop and coordinate, iteration through all rows and in each row accessing all columns directly
For emp = LBound(Employees, 1) To UBound(Employees, 1)
    Debug.Print Employees(emp, 0)
    Debug.Print Employees(emp, 1)
    Debug.Print Employees(emp, 2)
    Debug.Print Employees(emp, 3)
    Debug.Print Employees(emp, 4)
    Debug.Print Employees(emp, 5)
Next

'directly accessing element with coordinates
Debug.Print Employees(5, 5)

Denken Sie daran , dass es immer praktisch ist, eine Array-Map beizubehalten, wenn Sie multidimensionale Arrays verwenden.

Drei-Dimension-Array

Für das 3D-Array verwenden wir dieselbe Prämisse wie das 2D-Array. Zusätzlich werden nicht nur der Mitarbeiter und die Informationen gespeichert, sondern auch das Gebäude, in dem sie arbeiten.

Das 3D-Array enthält die Angestellten (können als Zeilen betrachtet werden), die Informationen (Spalten) und das Gebäude, die als unterschiedliche Tabellen in einem Excel-Dokument betrachtet werden können. Sie haben die gleiche Größe zwischen ihnen, aber jede Tabelle hat ein unterschiedliche Informationen in den Zellen / Elementen. Das 3D-Array enthält n Anzahl von 2D-Arrays.

Erstellen

Ein 3D-Array benötigt 3 Koordinaten, um initialisiert zu werden. Dim 3Darray(2,5,5) As Variant die erste Koordinate des Arrays die Anzahl der Gebäude / Pläne (verschiedene Reihen- und Spaltensätze) sein, die zweite Koordinate definiert die Zeilen und die dritte Säulen. Das oben genannte Dim ergibt ein 3D-Array mit 108 Elementen ( 3*6*6 ), das effektiv 3 verschiedene Sätze von 2D-Arrays enthält.

Dim ThreeDArray As Variant
'initialise your ThreeDArray array as variant
ReDim ThreeDArray(1, 50, 5)
'declaring an 3D array that can store two sets of 51 employees with 6 elements of information each, but starts empty
'the array size is 2 x 51 x 6 and contains 612 elements

For building = 0 To UBound(ThreeDArray, 1)
    'for each building/set in the array
    For employee = 0 To UBound(ThreeDArray, 2)
    'for each employee/row in the array
        For information_e = 0 To UBound(ThreeDArray, 3)
        'for each information element/column in the array
            
            ThreeDArray(building, employee, information_e) = InformationNeeded ' InformationNeeded would be the data to fill the array
        'iterating the full array will allow for direct attribution of information into the element coordinates
        Next
    Next
Next

Größenänderung

Das Ändern der Größe eines 3D-Arrays ähnelt dem Ändern der Größe eines 2D-Arrays. Erstellen Sie zunächst ein temporäres Array mit der gleichen Größe des Originals, indem Sie eins in der Koordinate des Parameters hinzufügen, um zu erhöhen. Die erste Koordinate erhöht die Anzahl der Sätze im Array, die zweite und die dritte Koordinaten erhöhen die Anzahl der Zeilen oder Spalten in jedem Satz.

Das folgende Beispiel erhöht die Anzahl der Zeilen in jedem Satz um eine und füllt die zuletzt hinzugefügten Elemente mit neuen Informationen.

Dim TempEmp As Variant
'initialise your temp array as variant
ReDim TempEmp(UBound(ThreeDArray, 1), UBound(ThreeDArray, 2) + 1, UBound(ThreeDArray, 3))
'ReDim/Resize Temp array as a 3D array with size UBound(ThreeDArray)+1 = (last element in Employees 2nd dimension) + 1,
'the other dimension remains the same as the original array. we effectively add 1 row in the for each set of the 3D array

'transfer
For building = LBound(ThreeDArray, 1) To UBound(ThreeDArray, 1)
    For emp = LBound(ThreeDArray, 2) To UBound(ThreeDArray, 2)
        For info = LBound(ThreeDArray, 3) To UBound(ThreeDArray, 3)
            'to transfer ThreeDArray into TempEmp by iterating all sets in the 3D array and fill TempEmp with the corresponding element value in each set of each row
            TempEmp(building, emp, info) = ThreeDArray(building, emp, info)
        
        Next
    Next
Next

'fill remaining
'to fill the remaining elements we need to iterate from the last "row" with values to the last row in the array in each set, remember that the first empty element is the original array Ubound() plus 1
For building = LBound(TempEmp, 1) To UBound(TempEmp, 1)
    For emp = UBound(ThreeDArray, 2) + 1 To UBound(TempEmp, 2)
        For info = LBound(TempEmp, 3) To UBound(TempEmp, 3)
            
            TempEmp(building, emp, info) = InformationNeeded & "NewRow"
        
        Next
    Next
Next

'erase Employees, attribute Temp array to Employees and erase Temp array
Erase ThreeDArray
ThreeDArray = TempEmp
Erase TempEmp

Elementwerte ändern und lesen

Das Lesen und Ändern der Elemente auf dem 3D-Array kann auf ähnliche Weise erfolgen wie das 2D-Array. Passen Sie einfach die zusätzliche Ebene in den Schleifen und Koordinaten an.

Do
' using Do ... While for early exit
    For building = 0 To UBound(ThreeDArray, 1)
        For emp = 0 To UBound(ThreeDArray, 2)
            If ThreeDArray(building, emp, 0) = "Gloria" And ThreeDArray(building, emp, 1) = "Stephan" Then
            'if value found
                ThreeDArray(building, emp, 1) = "Married, Last Name Change"
                Exit Do
                'don't iterate through all the array unless necessary
            End If
        Next
    Next
Loop While False

'nested loop, will iterate through all elements
For building = LBound(ThreeDArray, 1) To UBound(ThreeDArray, 1)
    For emp = LBound(ThreeDArray, 2) To UBound(ThreeDArray, 2)
        For info = LBound(ThreeDArray, 3) To UBound(ThreeDArray, 3)
            Debug.Print ThreeDArray(building, emp, info)
        Next
    Next
Next

'loop and coordinate, will iterate through all set of rows and ask for the row plus the value we choose for the columns
For building = LBound(ThreeDArray, 1) To UBound(ThreeDArray, 1)
    For emp = LBound(ThreeDArray, 2) To UBound(ThreeDArray, 2)
        Debug.Print ThreeDArray(building, emp, 0)
        Debug.Print ThreeDArray(building, emp, 1)
        Debug.Print ThreeDArray(building, emp, 2)
        Debug.Print ThreeDArray(building, emp, 3)
        Debug.Print ThreeDArray(building, emp, 4)
        Debug.Print ThreeDArray(building, emp, 5)
    Next
Next

'directly accessing element with coordinates
Debug.Print Employees(0, 5, 5)