VBA
Tablice

Deklarowanie tablicy w VBA

Deklaracja tablicy jest bardzo podobna do deklaracji zmiennej, z tym wyjątkiem, że musisz zadeklarować wymiar tablicy zaraz po jej nazwie:

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

Domyślnie tablice w VBA są indeksowane od ZERO , więc liczba w nawiasie nie odnosi się do rozmiaru tablicy, ale raczej do indeksu ostatniego elementu

Dostęp do elementów

Dostęp do elementu tablicy odbywa się za pomocą nazwy tablicy, a następnie indeksu elementu w nawiasie:

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

Indeksowanie macierzy

Możesz zmienić indeksowanie tablic, umieszczając ten wiersz na górze modułu:

Option Base 1

W tym wierszu wszystkie tablice zadeklarowane w module będą indeksowane od JEDNEJ .

Określony indeks

Możesz także zadeklarować każdą tablicę za pomocą własnego indeksu, używając słowa kluczowego To oraz dolnej i górnej granicy (= indeks):

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

Deklaracja dynamiczna

Jeśli nie znasz rozmiaru tablicy przed jej deklaracją, możesz użyć deklaracji dynamicznej i słowa kluczowego ReDim :

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

Zauważ, że użycie słowa kluczowego ReDim usunie wszelką poprzednią zawartość tablicy. Aby temu zapobiec, możesz użyć słowa kluczowego Preserve po 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

Użyj podziału, aby utworzyć tablicę z łańcucha

Funkcja podziału

zwraca zerową, jednowymiarową tablicę zawierającą określoną liczbę podciągów.

Składnia

Podziel (wyrażenie [, separator [, limit [, porównaj ]]] )

Ustawienia

Argument porównania może mieć następujące wartości:

Przykład

W tym przykładzie pokazano, jak działa Split, pokazując kilka stylów. Komentarze pokażą zestaw wyników dla każdej z różnych wykonanych opcji podziału. Na koniec pokazano, jak zapętlić zwracaną tablicę łańcuchów.

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

Iterowanie elementów tablicy

W następnym

Użycie zmiennej iteratora jako numeru indeksu jest najszybszym sposobem na iterację elementów tablicy:

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

Zagnieżdżone pętle mogą służyć do iteracji tablic wielowymiarowych:

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

Dla każdego ... Dalej

A For Each...Next pętli można również użyć do iteracji tablic, jeśli wydajność nie ma znaczenia:

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

Pętla For Each będzie iterować wszystkie wymiary od zewnętrznego do wewnętrznego (w tej samej kolejności, w jakiej elementy są ułożone w pamięci), więc nie ma potrzeby zagnieżdżania pętli:

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

Zauważ, że pętle For Each najlepiej nadają się do iteracji obiektów Collection , jeśli liczy się wydajność.

Wszystkie 4 fragmenty powyżej dają taki sam wynik:

 0
 1
 2
 3

Tablice dynamiczne (zmiana rozmiaru i obsługa dynamiczna)

Dynamiczne tablice

Dynamiczne dodawanie i zmniejszanie zmiennych w tablicy jest ogromną zaletą, gdy przetwarzane informacje nie mają określonej liczby zmiennych.

Dynamiczne dodawanie wartości

Możesz po prostu zmienić rozmiar tablicy za ReDim instrukcji ReDim , spowoduje to zmianę rozmiaru tablicy, ale jeśli chcesz zachować informacje już zapisane w tablicy, potrzebujesz części Preserve .

W poniższym przykładzie tworzymy tablicę i zwiększamy ją o jedną zmienną w każdej iteracji, zachowując wartości znajdujące się już w tablicy.

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

Dynamiczne usuwanie wartości

Możemy użyć tej samej logiki, aby zmniejszyć tablicę. W tym przykładzie wartość „last” zostanie usunięta z tablicy.

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

Resetowanie tablicy i ponowne użycie dynamiczne

Równie dobrze możemy ponownie wykorzystać utworzone przez nas tablice, aby nie mieć ich zbyt wiele w pamięci, co spowolniłoby czas działania. Jest to przydatne w przypadku tablic o różnych rozmiarach. Jednym fragmentem, którego można użyć do ponownego wykorzystania tablicy, jest ReDim tablicy z powrotem do (0) , przypisanie jednej zmiennej do tablicy i swobodne powiększanie tablicy.

W poniższym fragmencie tworzę tablicę o wartościach od 1 do 40, opróżniam tablicę i napełniam tablicę wartościami od 40 do 100, wszystko to odbywa się dynamicznie.

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

Jagged Arrays (Arrays of Arrays)

Jagged Arrays NOT Multidimensional Arrays

Tablice tablic (tablice poszarpane) nie są takie same jak tablice wielowymiarowe, jeśli pomyślimy o nich wizualnie Tablice wielowymiarowe wyglądałyby jak macierze (prostokątne) ze zdefiniowaną liczbą elementów na swoich wymiarach (tablice wewnętrzne), podczas gdy tablica poszarpana byłaby jak roczna kalendarz z wewnętrznymi tablicami mającymi różną liczbę elementów, np. dni w różnych miesiącach.

Chociaż Jagged Arrays są dość niechlujne i trudne w użyciu ze względu na ich zagnieżdżone poziomy i nie mają zbyt dużego bezpieczeństwa typu, ale są bardzo elastyczne, pozwalają dość łatwo manipulować różnymi typami danych i nie muszą zawierać nieużywanych lub puste elementy.

Tworzenie poszarpanej tablicy

W poniższym przykładzie zainicjujemy poszarpaną tablicę zawierającą dwie tablice, jedną dla Nazw i drugą dla Liczb, a następnie uzyskując dostęp do jednego elementu każdego

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

Dynamiczne tworzenie i czytanie postrzępionych tablic

Równie dobrze możemy być bardziej dynamiczni w budowaniu tablic, wyobraźmy sobie, że mamy arkusz danych klienta w programie Excel i chcemy zbudować tablicę do wyświetlania danych klienta.

   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

Dynamicznie zbudujemy tablicę nagłówków i tablicę klientów, nagłówek będzie zawierał tytuły kolumn, a tablica klientów będzie zawierać informacje o każdym kliencie / wierszu jako tablice.

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.

Rezultatem powyższego fragmentu jest Jagged Array z dwoma tablicami, jedna z tych tablic z 4 elementami, 2 poziomami wcięcia, a druga sama jest kolejną Jagged Array zawierającą 5 tablic po 4 elementy i 3 poziomy wcięć, patrz poniżej struktura:

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)

Aby uzyskać dostęp do informacji, należy wziąć pod uwagę strukturę tworzonej Jagged Array, w powyższym przykładzie widać, że Main Array zawiera tablicę Headers i tablicę tablic ( Customers ), a zatem różne sposoby dostęp do elementów.

Teraz przeczytamy informacje o Main Array i wydrukujemy informacje o każdym kliencie jako 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

PAMIĘTAJ, aby śledzić strukturę Twojej Jagged Array, w powyższym przykładzie, aby uzyskać dostęp do Nazwy klienta, Main_Array -> Customers -> CustomerNumber -> Name do Main_Array -> Customers -> CustomerNumber -> Name która jest trzy poziomy, aby zwrócić "Person4" będziesz potrzebować lokalizacja klientów w tablicy głównej, następnie lokalizacja klienta czterech w tablicy Jagged klientów, a na koniec lokalizacja potrzebnego elementu, w tym przypadku Main_Array(1)(3)(0) którą jest Main_Array(Customers)(CustomerNumber)(Name) .

Tablice wielowymiarowe

Tablice wielowymiarowe

Jak sama nazwa wskazuje, tablice wielowymiarowe to tablice, które zawierają więcej niż jeden wymiar, zwykle dwa lub trzy, ale mogą mieć do 32 wymiarów.

Multi-tablica działa jak matryca z różnymi poziomami, na przykład porównanie jednego, dwóch i trzech wymiarów.

Jeden wymiar to typowa tablica, wygląda jak lista elementów.

Dim 1D(3) as Variant

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

Dwa wymiary wyglądałyby jak siatka Sudoku lub arkusz Excela, podczas inicjowania tablicy określałbyś, ile wierszy i kolumn miałaby tablica.

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)

Trzy wymiary zaczną wyglądać jak Kostka Rubika, podczas inicjowania tablicy zdefiniowałbyś wiersze i kolumny oraz warstwy / głębokości, jakie miałaby tablica.

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)

Dalsze wymiary można by pomyśleć jako zwielokrotnienie 3D, więc 4D (1,3,3,3) byłyby dwiema równoległymi tablicami 3D.

Tablica dwuwymiarowa

Tworzenie

Poniższy przykład będzie kompilacją listy pracowników, każdy pracownik będzie miał zestaw informacji na liście (imię, nazwisko, adres, adres e-mail, telefon ...), przykład zasadniczo będzie przechowywany w tablicy ( pracownik, informacja) będący (0,0) to imię pierwszego pracownika.

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

Zmiana rozmiaru

Zmiana rozmiaru lub ReDim Preserve tablicę Multi-Array, jak norma dla tablicy One-Dimension, otrzyma błąd, zamiast tego informacje muszą zostać przesłane do tablicy tymczasowej o takim samym rozmiarze jak oryginał plus liczba wierszy / kolumn do dodania. W poniższym przykładzie zobaczymy, jak zainicjować tablicę temperatur, przenieść informacje z oryginalnej tablicy, wypełnić pozostałe puste elementy i zastąpić tablicę temp oryginalną tablicą.

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

Zmiana wartości elementu

Aby zmienić / zmienić wartości w pewnym elemencie, można to zrobić po prostu wywołując współrzędną w celu zmiany i nadając jej nową wartość: Employees(0, 0) = "NewValue"

Alternatywnie można iterować przez warunki użycia współrzędnych, aby dopasować wartości odpowiadające wymaganym parametrom:

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

Czytanie

Dostęp do elementów w tablicy można wykonać za pomocą zagnieżdżonej pętli (iteracja każdego elementu), pętli i współrzędnych (iteracja wierszy i bezpośredni dostęp do kolumn) lub bezpośredni dostęp za pomocą obu współrzędnych.

'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)

Pamiętaj , że zawsze przydaje się utrzymywanie mapy tablic podczas korzystania z tablic wielowymiarowych, mogą łatwo doprowadzić do zamieszania.

Tablica trójwymiarowa

W przypadku tablicy 3D zastosujemy tę samą przesłankę co tablica 2D, z dodatkiem nie tylko przechowywania pracownika i informacji, ale także budynku, w którym pracują.

Tablica 3D będzie zawierać pracowników (można traktować je jako wiersze), informacje (kolumny) i budynek, które mogą być traktowane jako różne arkusze w dokumencie programu Excel, mają między sobą taki sam rozmiar, ale każdy arkusz ma inny zestaw informacji w jego komórkach / elementach. Tablica 3D będzie zawierać n liczby tablic 2D.

Tworzenie

Tablica 3D wymaga 3 współrzędnych do zainicjowania Dim 3Darray(2,5,5) As Variant pierwszą współrzędną w tablicy będzie liczba budynków / arkuszy (różne zestawy rzędów i kolumn), druga współrzędna określi rzędy i trzecia Kolumny Powyższy Dim spowoduje powstanie tablicy 3D ze 108 elementami ( 3*6*6 ), skutecznie mającymi 3 różne zestawy tablic 2D.

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

Zmiana rozmiaru

Zmiana rozmiaru tablicy 3D jest podobna do zmiany rozmiaru 2D, najpierw utwórz tablicę tymczasową o tym samym rozmiarze oryginału, dodając ją do współrzędnej parametru, aby zwiększyć, pierwsza współrzędna zwiększy liczbę zestawów w tablicy, druga i trzecie współrzędne zwiększą liczbę rzędów lub kolumn w każdym zestawie.

Poniższy przykład zwiększa liczbę wierszy w każdym zestawie o jeden i wypełnia ostatnio dodane elementy nowymi informacjami.

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

Zmiana wartości elementu i odczytu

Odczytywanie i zmienianie elementów w tablicy 3D można wykonać podobnie do tego, w jaki sposób robimy tablicę 2D, po prostu dostosuj dodatkowy poziom w pętlach i współrzędnych.

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)