{"id":55000439,"date":"2024-06-01T00:00:00","date_gmt":"2024-08-07T09:57:53","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=439"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"VBA_Basics_Mit_Arrays_programmieren","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/VBA_Basics_Mit_Arrays_programmieren\/","title":{"rendered":"VBA Basics: Mit Arrays programmieren"},"content":{"rendered":"

\"\"Arrays sind eine einfache Möglichkeit, mit VBA-Bordmitteln mehrere Werte unter einem einzigen Namen zu speichern und effizient auf diese Werte zuzugreifen. In diesem Artikel geben wir eine umfassende Einführung in die Verwendung von Arrays in VBA einschließlich der Definition, Deklaration, Manipulation und der Anwendung in verschiedenen Szenarien. <\/b><\/p>\n

Arrays sind Datenstrukturen, die Elemente desselben Datentyps speichern. Dabei werden die Elemente in einer oder mehreren Dimensionen abgespeichert und können über den Index der verschiedenen Dimensionen abgefragt werden.<\/p>\n

Normalerweise gibt man den Datentyp eines Arrays explizit an (zum Beispiel Integer <\/b>oder String<\/b>), wir können aber auch den Datentyp Variant <\/b>zum Speichern beliebiger Informationen verwenden.<\/p>\n

Bevor man Daten in ein Array schreiben kann, muss man diese deklarieren und dabei die Menge der aufzunehmenden Elemente definieren. Diese Menge kann man auch im Nachhinein anpassen. Die Deklaration von Arrays unterscheidet sich durch das Hinzufügen eines Klammernpaares zum Namen der Variablen von der Deklaration einfacher Variablen:<\/p>\n

Dim <\/span>strBeispiel(2) As String<\/span><\/pre>\n
Index 0- oder 1-basiert<\/h2>\n
Der Wert 2<\/b> in Klammern gibt den Wert des Indexes des letzten Elements an. Damit ist nicht eindeutig angegeben, wie viele Elemente das Array aufnehmen kann. Dies hängt davon ab, ob der Index 0- oder 1-basiert ist. Standardmäßig ist der Index 0-basiert. Wir können dies explizit festlegen, indem wir in dem jeweiligen Modul ganz oben eine entsprechende Angabe machen. Um sicherzustellen, dass wir tatsächlich einen 0-basierten Index verwenden, geben wir dort folgende Zeile an:<\/p>\n
Option Base 0<\/pre>\n
Wir können auch einen 1-basierten Index verwenden:<\/p>\n
Option Base 1<\/pre>\n
In diesem Fall kann das Array mit der Angabe 2<\/b> in Klammern maximal zwei Elemente aufnehmen, sonst drei.<\/p>\n
Untersten und obersten Index-Wert herausfinden<\/h2>\n
Meist für das Durchlaufen von Array in einer Schleife wollen wir den Wert für den untersten und den obersten Index ermitteln. Dazu dienen die folgenden beiden Funktionen:<\/p>\n
    \n
  • LBound<\/b>: Ermittelt den Wert des untersten Indexes.<\/li>\n
  • UBound<\/b>: Ermittelt den Wert des obersten Indexes.<\/li>\n<\/ul>\n
    Wir testen diese Funktionen für ein Array mit 0-basiertem Index und dem größte Indexwert von 2:<\/p>\n
    Dim <\/span>strBeispiel(2) As String<\/span>\r\nDebug.Print<\/span> \"Unterer Indexwert: \" & LBound<\/span>(strBeispiel)\r\nDebug.Print<\/span> \"Oberer Indexwert: \" & UBound<\/span>(strBeispiel)<\/pre>\n
    Das Ergebnis lautet:<\/p>\n
    Unterer Indexwert: 0\r\nOberer Indexwert: 2<\/pre>\n
    Stellen wir Option Base 1 <\/b>ein, erhalten wir:<\/p>\n
    Unterer Indexwert: 1\r\nOberer Indexwert: 2<\/pre>\n
    Individuelle Indexwerte<\/h2>\n
    Wir können die Indexwerte auch komplett selbst festlegen. Das folgende Array enthält die Indexwerte 2 <\/b>und 3<\/b>:<\/p>\n
    Dim <\/span>strEigene(2 To 3)<\/pre>\n
    Array füllen<\/h2>\n
    Um das Array zu füllen, können wir direkt über den Indexwert auf das jeweilige Element zugreifen:<\/p>\n
    strBeispiel(0) = \"Text 0\"\r\nstrBeispiel(1) = \"Text 1\"\r\nstrBeispiel(2) = \"Text 2\"<\/pre>\n
    Die Inhalte fragen wir wie folgt ab:<\/p>\n
    Debug.Print<\/span> strBeispiel(0)\r\nDebug.Print<\/span> strBeispiel(1)\r\nDebug.Print<\/span> strBeispiel(2)<\/pre>\n
    Array mit Werten initialisieren<\/h2>\n
    Diese Werte können wir auch direkt in einer Zeile zuweisen. Dazu nutzen wir die Array<\/b>-Funktion.<\/p>\n
    Da sie das Ergebnis als Variant<\/b>-Array liefert, müssen wir das Array entsprechend deklarieren. Außerdem dürfen wir die Anzahl der Elemente hier nicht vordefinieren:<\/p>\n
    Dim <\/span>varBeispiel() As Variant<\/span>\r\nvarBeispiel = Array(\"Text 0\", \"Text 1\", \"Text 2\")<\/pre>\n
    Array per Schleife auslesen<\/h2>\n
    Mithilfe der oben vorgestellten Funktionen LBound <\/b>und UBound <\/b>können wir die Elemente auch in einer Schleife durchlaufen und ausgeben:<\/p>\n
    Dim <\/span>i As Integer<\/span>\r\nFor i = LBound<\/span>(strBeispiel) To UBound<\/span>(strBeispiel)\r\n     Debug.Print<\/span> strBeispiel(i)\r\nNext<\/span> i<\/pre>\n
    Array-Größe zur Laufzeit anpassen<\/h2>\n
    Nicht immer wissen wir bereits vorher, wie viele Elemente das Array aufnehmen soll. Deshalb können wir es zunächst einmal ohne Angabe der Menge deklarieren und dann zur Laufzeit die Anzahl der Elemente festlegen. Dabei können wir entscheiden, ob bei dieser Änderung die vorhandenen Inhalte beibehalten oder verworfen werden sollen.<\/p>\n
    Wir deklarieren das Array zuerst ohne Elemente:<\/p>\n
    Dim <\/span>strBeispiel() As String<\/span><\/pre>\n
    Dann stellen wir die Größe auf den maximalen Index von 0 <\/b>ein, also für ein Element, und weisen diesem einen Wert hinzu:<\/p>\n
    ReDim strBeispiel(0)\r\nstrBeispiel(0) = \"Text 0\"<\/pre>\n
    Nun wollen wir zwei weitere Werte hinzufügen, aber den Wert im ersten Element behalten. Dazu stellen wir wieder mit ReDim <\/b>den höchsten Index auf 2 <\/b>ein und verwenden zusätzlich das Schlüsselwort Preserve<\/b>, um die Inhalte <\/p>\n
    ReDim Preserve strBeispiel(2)\r\nstrBeispiel(1) = \"Text 1\"\r\nstrBeispiel(2) = \"Text 2\"<\/pre>\n
    Wenn wir Preserve <\/b>nicht setzen würden, wäre strBeispiel(0)<\/b> anschließend leer beziehungsweise würde eine leere Zeichenkette enthalten.<\/p>\n
    Hier wird dann der Standardwert für den jeweiligen Datentyp gesetzt, für String <\/b>also eine leere Zeichenkette oder für Zahlendatentypen der Wert 0<\/b>.<\/p>\n
    Mehrdimensionale Arrays<\/h2>\n
    Wir können Arrays auch mehrdimensional gestalten. Hier deklarieren wir ein Array, das in der ersten Dimension als obersten Index den Wert 1<\/b> enthält und in der zweiten Dimension den Wert 2<\/b>. Wenn die Indizes 0-basiert sind, haben wir also ein Array mit 2 x 3 Elementen, das wir wie folgt füllen können:<\/p>\n
    Dim <\/span>str2x3(1, 2) As String<\/span>\r\nstr2x3(0, 0) = \"0-0\"\r\nstr2x3(0, 1) = \"0-1\"\r\nstr2x3(0, 2) = \"0-2\"\r\nstr2x3(1, 0) = \"1-0\"\r\nstr2x3(1, 1) = \"1-1\"\r\nstr2x3(1, 2) = \"1-2\"<\/pre>\n
    Grenzen für mehrdimensionale Array ermitteln<\/h2>\n
    Die Dimensionen selbst werden nicht 0-basiert, sondern 1-basiert indiziert, was ein wenig verwirrend sein kann. Jedenfalls ermitteln wir die Grenzen eines zweidimensionalen Arrays wie folgt. Für die erste Dimension:<\/p>\n
    Debug.Print<\/span> LBound<\/span>(str2x3, 1)\r\nDebug.Print<\/span> UBound<\/span>(str2x3, 1)<\/pre>\n
    Für die zweite Dimension:<\/p>\n
    Debug.Print<\/span> LBound<\/span>(str2x3, 2)\r\nDebug.Print<\/span> UBound<\/span>(str2x3, 2)<\/pre>\n
    Mehrdimensionales Array durchlaufen<\/h2>\n
    Um ein solches Array zu durchlaufen und auf die Werte zuzugreifen, benötigen wir so viele For…Next<\/b>-Schleifen wie Dimensionen.<\/p>\n
    Im folgenden Beispiel sind dies zwei:<\/p>\n
    Dim <\/span>x As Integer<\/span>\r\nDim <\/span>y As Integer<\/span>\r\n...\r\nFor x = LBound<\/span>(str2x3, 1) To UBound<\/span>(str2x3, 1)\r\n     For y = LBound<\/span>(str2x3, 2) To UBound<\/span>(str2x3, 2)\r\n         Debug.Print<\/span> x, y, str2x3(x, y)\r\n     Next<\/span> y\r\nNext<\/span> x<\/pre>\n
    Array leeren<\/h2>\n
    Wenn wir die Elemente des Arrays vollständig leeren wollen, können wir das mit der Erase<\/b>-Anweisung erledigen:<\/p>\n
    Erase str2x3<\/pre>\n
    Prüfen, ob eine Variable ein Array enthält<\/h2>\n
    Mit der IsArray<\/b>-Funktion können wir prüfen, ob eine Variable ein Array ist:<\/p>\n
    Debug.Print<\/span> IsArray(str2x3)<\/pre>\n
    Prüfen, ob ein Array gefüllt ist<\/h2>\n
    Schließlich hier noch eine Funktion, die prüft, ob ein Array überhaupt initialisiert ist:<\/p>\n
    Public Function <\/span>IstArrayGefuellt(var As Variant<\/span>) As Boolean<\/span>\r\n      Dim <\/span>intTest As Integer<\/span>\r\n      If <\/span>IsArray(var) Then<\/span>\r\n          On Error Resume Next<\/span>\r\n          intTest = LBound<\/span>(var)\r\n          If <\/span>Err.Number = 0 Then<\/span>\r\n              IstArrayGefuellt = True<\/span>\r\n          Else<\/span>\r\n              IstArrayGefuellt = False<\/span>\r\n          End If<\/span>\r\n      Else<\/span>\r\n          IstArrayGefuellt = False<\/span>\r\n      End If<\/span>\r\nEnd Function<\/span><\/pre>\n
    Für ein frisch initialisiertes Array ohne Dimensionen liefert dies den Wert False<\/b>:<\/p>\n
    Dim <\/span>varArray() As Variant<\/span>\r\nDebug.Print<\/span> IstArrayGefuellt(varArray)<\/pre>\n","protected":false},"excerpt":{"rendered":"
    Arrays sind eine einfache Möglichkeit, mit VBA-Bordmitteln mehrere Werte unter einem einzigen Namen zu speichern und effizient auf diese Werte zuzugreifen. In diesem Artikel geben wir eine umfassende Einführung in die Verwendung von Arrays in VBA einschließlich der Definition, Deklaration, Manipulation und der Anwendung in verschiedenen Szenarien. <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[662024,66032024,44000026,44000025,44000033],"tags":[],"yst_prominent_words":[],"class_list":["post-55000439","post","type-post","status-publish","format-standard","hentry","category-662024","category-66032024","category-Outlook_programmieren","category-VBAProgrammierung","category-Visual_Basic_Programmierung"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000439","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/comments?post=55000439"}],"version-history":[{"count":0,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000439\/revisions"}],"wp:attachment":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/media?parent=55000439"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/categories?post=55000439"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/tags?post=55000439"},{"taxonomy":"yst_prominent_words","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/yst_prominent_words?post=55000439"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}