Glengamoi (Forum) · AspHeute · .NET Heute (RSS-Suche) · AspxFiles (Wiki) · .NET Blogs

Das Array, unendliche Weiten?

Geschrieben von: Stefan Gründhammer
Kategorie: ASP Grundlagen

This printed page brought to you by AlphaSierraPapa

In diesem Artikel werden Sie lernen wie man ein-, zwei- und mehrdimensionale Arrays deklariert und mit ihnen umgeht. Ich werde in diesem Array-Grundlagenartikel auch noch darauf eingehen, wie man diese einsetzen kann.

Wie oft ist es Ihnen schon passiert, daß Sie eine Liste von Elementen gehabt haben, welche Sie so schnell und einfach wie möglich speichern, und dann auch wieder ansprechen und verwenden wollten - und vielleicht nicht gewußt haben, wie Sie das machen sollen: hier kommt die Lösung. All das und vieles mehr funktioniert mit Arrays.

Allgemeines zu Arrays

Was ist ein Array? Diese Frage stellt sich jeder Programmierer mindestens einmal in seinem Leben, ich werde versuchen Ihnen diese Frage so einfach wie möglich anhand einiger Anwendungsbeispiele und umfangreichen Beschreibungen zu beantworten. Als erstes müssen Sie wissen, daß man jedes Array deklarieren muß. Es ist unerläßlich Arrays zu dimensionieren, da VBScript wissen muß wie viele Elemente ein Array haben soll. Die Ausnahme zu dieser Regel sind die dynamischen Arrays.

Verwenden Sie für die Entwicklung Ihrer Scripts wenn möglich immer <% Option Explicit %>, denn damit vermeiden Sie Tippfehler (und erhöhen nebenbei auch noch die Geschwindigkeit). Alle Arrays, die wir hier besprechen sind nullbasierende, das heißt der Index des Arrays beginnt bei 0. Wenn Sie z.B. ein eindimensionales Array mit 15 Elementen generieren wollen, dann sieht das so aus: ArrayName(14). Sie können jeden Wert (Eintrag bzw. jedes Element) in Ihrem Array mit Hilfe des Arrayindex ansprechen und auch damit arbeiten.

Es gibt grundsätzlich zwei Typen von Arrays: einerseits Arrays konstanter (statische) und andererseits Arrays variabler Größe (dynamische Arrays). Statische Arrays können natürlich auch mehrere Dimensionen haben, genauso wie dynamische. Arrays können bis zu 60 Dimensionen haben, aber meistens werden nicht mehr als drei oder vier Dimensionen gebraucht um die alltäglichen Probleme zu lösen.

Eindimensionale Arrays

Wie kann ich mir ein eindimensionales Array vorstellen? Eigentlich sehr einfach: ein eindimensionales Array ist nichts anderes als eine Kette (Spalte oder auch Zeile) von Elementen mit fortlaufendem Index von 0 beginnend bis Anzahl der Elemente (n) minus 1.

Dimensionierung eines eindimensionalen Arrays

Wie deklarieren Sie eine Variable in VBScript? Ganz einfach, entweder implizit indem Sie einen Variablennamen in Ihrem Script verwenden (wenn Sie Option Explicit nicht einsetzen), oder explizit durch Verwendung des Dim Statements. Dim Variablenname deklariert eine Variable und allokiert gleichzeitig Speicherplatz für diese Variable. Die Syntax zum Deklarieren eines eindimensionalen Arrays ist sehr einfach: arrTest(Größe). Der Name des Arrays ist arrTest und das Wort "Größe" (ist eine ganze Zahl) gibt nicht nur die Elementanzahl des Arrays sondern auch dessen Dimension an, und die wäre in diesem Fall 1.

Eigentlich gibt es zwei Möglichkeiten ein Array zu deklarieren:

Möglichkeit 1:

 1: <% @LANGUAGE = VBScript %>
 2: <% Option Explicit %>
 3: <% Dim arrTest(4)
 4:     arrTest(0)=1
 5:     arrTest(1)=2
 6:     arrTest(2)=3
 7:     arrTest(3)=4
 8:     arrTest(4)=5
 9: %>

Option Explicit wurde bereits weiter oben kurz erwähnt. Dieses Statement muß vor allen anderen Statements in Ihrem Script stehen. Es zwingt Sie alle Ihre Variablen explizit zu deklarieren, was von großem Nutzen für Ihre Scripts sein kann. Alle nichtdeklarierten Variablen erzeugen dann sofort eine Fehlermeldung.

In diesem Beispiel deklariere ich mit Dim arrTest(4) ein Array der fixen Größe 5, und nicht der Größe 4 da Arrays in VBScipt nullbasierend sind. In den Zeilen 4 bis 8 befülle ich das Array mit Werten, und zwar indem ich z.B. mit arrTest(0)=1 dem ersten Feld den Wert 1 zuweise.

Möglichkeit 2:

 1: <% @LANGUAGE = VBScript %>
 2: <% Option Explicit %>
 3: <% Dim arrTest, x
 4:    arrTest = Array(1,2,3,4,5,6,7,8)
 5:    For x = 0 to UBound(arrTest)
 6:     Response.Write "arrTest" & "(" & x & ") enthält " & arrTest(x) & "<br>"
 7:    Next
 8: %>

In diesem Beispiel dimensioniere ich einfach eine Variable mit Namen arrTest in Zeile 3. In Zeile 4 benutze ich die Array-Funktion um aus der einfachen Variablen ein Array zu machen, und das Array gleich mit Werten von 1 bis 8 zu befüllen. Auf die Array-Funktion gehe ich etwas später noch genauer ein.

Eine Dimension kann doch noch nicht alles sein, da muß es doch noch mehr geben. Richtig - und zwar zwei- und mehrdimensionale Arrays.

Zwei und mehrdimensionale Arrays

Eine Dimension ist ja recht nett kann aber in vielen, sehr vielen Fällen zu wenig sein.

Zweidimensionale Arrays

Stellen Sie sich vor, Sie haben eine Gehaltsliste mit zwei Spalten: in der einen steht der Nachname eines Ihrer Mitarbeiter und in der zweiten dessen Gehalt. Wir werden ein Array mit 5 Zeilen und 2 Spalten generieren.

 1: <% @LANGUAGE = VBScript %>
 2: <% Option Explicit %>
 3: <% Dim intZeile
 4:    Dim arrGehalt(4,1)
 5:    arrGehalt(0,0) = "Huber"
 6:    arrGehalt(1,0) = "Meier"
 7:    arrGehalt(2,0) = "Bauer"
 8:    arrGehalt(3,0) = "Müller"
 9:    arrGehalt(4,0) = "Kaiser"
10: 
11:    arrGehalt(0,1) = 21000
12:    arrGehalt(1,1) = 22000
13:    arrGehalt(2,1) = 23000
14:    arrGehalt(3,1) = 24000
15:    arrGehalt(4,1) = 25000
16: 
17: For intZeile = 0 to 4
18:    Response.Write"Herr " & arrGehalt(intZeile,0)_
19:    & " erhält " & arrGehalt(intZeile,1) & "<br>"
20: Next
21: %>

In Zeile 3 deklariere ich eine Variabele die ich später nur in der For-Next Schleife zum Anzeigen des Arrays benutze. Mit Dim arrGehalt(4,1) deklariere ich ein zweidimensionales Array, wobei die erste Zahl in der Klammer (hier 4) die Anzahl der Reihen und die zweite Zahl (hier 1) die Anzahl der Spalten angibt. Zwei Zahlen in der Klammer getrennt durch einen Beistrich zeigen Ihnen an daß es sich hierbei um ein zweidimensionales Array handelt. Sie müssen sich dieses Array wie eine zweispaltige Tabelle mit 5 Zeilen vorstellen wobei jedes der Felder durch seinen Index bestehend aus zwei Zahlen, getrennt durch ein Komma, eindeutig angesprochen werden kann. Bildlich gesprochen: im linken oberen Eck steht die Zelle (0,0) im rechten unteren Eck die Zelle (4,1).

In den Zeilen 17 bis 20 schreibe ich das Array mittels For-Next-Schleife aus. Sie können sich diesen Code natürlich wieder downloaden - er hat den Namen zweidim.asp. Aber nun auf zu höheren Dimensionen...

Dreidimensionale Arrays

Dreidimensionale Arrays kommen schon viel seltener vor als zweidimensionale, sind aber für manche Probleme die einzige Lösung. Um Ihnen ein Bild über dreidimensionale Arrays zu geben, habe ich wieder ein Beispiel geschrieben. Na gut, eigentlich habe ich das zweidimensionale Beispiel einfach um ein Dimension erweitert...

 1: <% @LANGUAGE = VBScript %>
 2: <% Option Explicit %>
 3: <% Dim intZeile
 4:    Dim arrGehalt(4,1,1)
 5:    arrGehalt(0,0,0) = "Huber"
 6:    arrGehalt(1,0,0) = "Meier"
 7:    arrGehalt(2,0,0) = "Bauer"
 8:    arrGehalt(3,0,0) = "Müller"
 9:    arrGehalt(4,0,0) = "Kaiser"
10: 
11:    arrGehalt(0,1,0) = 21000
12:    arrGehalt(1,1,0) = 22000
13:    arrGehalt(2,1,0) = 23000
14:    arrGehalt(3,1,0) = 24000
15:    arrGehalt(4,1,0) = 25000
16: 
17:    arrGehalt(0,1,1) = 14 * arrGehalt (0,1,0)
18:    arrGehalt(1,1,1) = 14 * arrGehalt (1,1,0)
19:    arrGehalt(2,1,1) = 14 * arrGehalt (2,1,0)
20:    arrGehalt(3,1,1) = 14 * arrGehalt (3,1,0)
21:    arrGehalt(4,1,1) = 14 * arrGehalt (4,1,0)
22:
23: For intZeile = 0 to 4
24:   Response.Write "Herr " & arrGehalt(intZeile,0,0)_ 
25:   & " erhält " & arrGehalt(intZeile,1,0) & " monatlich "_
26:   & " und " & arrGehalt(intZeile,1,1) & "im Jahr <br>"
27: Next
27: %>

Ich habe in diesem Beispiel eine dritte Dimension eingeführt, und zwar genau so wie Sie es bis zu 60 mal machen können (Sie können max. 60 Dimensionen deklarieren) - einfach eine weitere Zahl für die Dimension in die Klammer schreiben und durch ein Komma trennen.

Mit Dim arrGehalt(4,1,1) in der Zeile 4 habe ich ein dreidimensionales Array deklariert, dieses Array hat folgende Maße: 5 Zeilen, 2 Spalten und 2 Schichten. Mit Schicht meine ich die Tiefe eines dreidimensionalen Arrays - man kann es sich wie ein Stapel Papier vorstellen, die Anzahl der Schichten entspricht dann der Anzahl der Blätter.

Viele von Ihnen werden sich fragen, warum ich das Monatsgehalt mit 14 multipliziere um das Jahresgehalt zu ermitteln - na ja, ganz einfach: in Österreich ist das nun mal so. Scherz beiseite, ich habe diese Multiplikation nur gemacht um Ihnen zu zeigen, daß man sich auf diese Weise etwas Arbeit erspart, und so nur einen Wert ändern muß wenn einer der Herren (oder Damen) eine Lohnerhöhung erhält.

In den Zeilen 23 bis 27 schreibe ich das dreidimensionale Array mit einigen Füllwörtern heraus. Sie sehen, auch das läßt sich ganz einfach machen.

Arrays in einem Array, auch das ist möglich

Sie können auch Arrays in einem Array abspeichern. Wenn Sie zum Beispiel ein eindimensionales Array arrMitarbeiter bestehend aus Vornamen, Nachnamen, Adresse, Telefonnummer und dazugehöriger Emailadresse in einem Array arrAbteilung speichern wollen, geht auch dies sehr einfach. Sehen Sie das Array arrMitarbeiter ganz einfach wie einen normalen Wert an, den Sie im Array arrAbteilung speichern wollen, und legen Sie das Array des ersten Mitarbeiters einfach in arrAbteilung(0,0) ab, und das nächste in arrAbteilung(1,0) usw.

Ich werde Ihnen das Speichern und wieder Ausschreiben eines Arrays in einem Array anhand eines sehr einfachen Beispiels demonstrieren (arrayimarray.asp).

 1: <% @LANGUAGE = VBScript %>
 2: <% Option Explicit %>
 3: <% Dim arrTest, arrHilfe(0), Trick, i
 4:        arrTest = Array(1,2,3,4,5,6,7,8,9)
 5:        arrHilfe(0) = arrTest
 6:        Trick = arrHilfe(0)
 7:    For i = 0 to UBound(Trick)
 8:        Response.Write Trick(i) & " "
 9:    Next
10: %>

In Zeile 4 befülle ich das Array arrTest mit Hilfe der Array-Funktion mit Zahlen von 1 bis 9. In Zeile 5 speichere ich arrTest im Array arrHilfe an der Position 0. Um das Array arrTest wieder ausschreiben zu können müssen Sie einen kleinen Trick anwenden: Sie müsssen arrHilfe(0) in einer anderen Variable (in unserem Fall Trick) speichern. Mit der For-Next-Schleife schreibe ich dann das Array wieder aus.

Sie können jetzt Arrays in einem Array speichern und damit arbeiten, zu bemerken ist allerdings noch daß der Datentyp der Elemente der einzelnen Arrays keine Rolle spielt, d.h. Sie können ein Array mit Zahlen ein anderes mit Strings und wieder ein anderes mit True oder False füllen.

Dynamische Arrays

Neben Arrays mit konstanter Größe gibt es auch noch welche mit variabler Größe. Diese werden üblicherweise Dynamische Arrays genannt. Sie können die Parameter dieser Arrays jederzeit an Ihre Anforderungen in Größe und Dimension anpassen. Zum Thema gibt es bereits den Artikel Dynamische Arrays - Fluch und Segen, der sehr ausführlich ist. Aus diesem Grund werde ich mich nur sehr kurz mit dynamischen Arrays befassen.

Der Vollständigkeit halber werde ich aber noch kurz einige wichtige Begriffe beschreiben. Da wäre wieder Dim, das in Verbindung mit einem Variablennamen und leeren Klammern ein dynamisches Array deklariert:

 <% Dim arrDyn() %>

Dim arrDyn() deklariert ein dynamisches Array ohne Dimensions- oder Größenangaben. Um das Array einsetzen zu können müssen Sie das Redim Statement verwenden.

 <% ReDim arrDyn(i) %>

In der obenstehenden Codezeile habe ich anstelle einer Zahl eine Variable verwendet - somit kann ich die Größe des Arrays dynamisch ändern. Aber Vorsicht bei der Verwendung des ReDim Statements: denn wenn Sie die Größe verändern, löschen Sie auch die Werte der einzelnen Elemente. Um das zu verhindern gibt es das Zauberwort Preserve. Mit ReDim Preserve arrDyn(3) verändern Sie die Größe Ihres Arrays ohne dessen Inhalt zu löschen.

Ich habe zum Thema dynamische Arrays natürlich wieder ein kleines Beispiel geschrieben (dynamisches.asp).

 1: <% @LANGUAGE = VBScript %>
 2: <% Option Explicit %>
 3: <% Dim arrDyn(), x, arrAbteilung, i, k
 4:       i=2
 5:       ReDim arrDyn(i)
 6:
 7:       arrDyn(0)= 1
 8:       arrDyn(1)= 2
 9:       arrDyn(2)= 3
10: %>
11: Das dynamische Array:<br>
12: <%
13:       For x = 0 to UBound(arrDyn)
14:           Response.Write arrDyn(x) & "<br>"
15:       Next
16: %>
17: Hier kommt das redimensionierte Array:<br>
18: <%
19:       ReDim Preserve arrDyn(3)
20:       arrDyn(3)= 4
21:
22:       For x = 0 to UBound(arrDyn)
23:           Response.Write arrDyn(x) & "<br>"
24:       Next
25: %>

In den Zeilen 3-9 dimensioniere ich das Array arrDyn(), weise ihm die Größe 2 zu und befülle es. In der Zeile 19 ändere ich die Größe meines Arrays, um aber den Inhalt des Arrays nicht zu verlieren muß ich das Preserve Statement verwenden. Um Ihnen zu beweisen, daß dem so ist schreibe ich danach das Array wieder aus. Sie können die Größe Ihrer Arrays beliebig oft ändern, denken Sie aber daran, daß beim Verkleinern des Arrays Einträge verloren gehen. Soviel zu dynamischen Arrays.

Praktische Anwendungsbeispiele für Arrays

Ich werde mich hier auf das Beschreiben von möglichen Anwendungen von Arrays beschränken, um den Rahmen dieses Artikels nicht zu sprengen. Sie können Arrays für die Implementierung einer Shopping-Applikation verwenden, indem Sie für jeden Kunden Ihrer Site ein Item-Array anlegen und dieses in der Sessionvariable speichern - das ist eine der einfachsten Lösungen für einen Shop. Sie können Arrays aber auch verwenden, wenn Sie mit Matrizen rechnen müssen. Bei großen Datenmengen empfiehlt es sich aber eine andere Programmiersprache zu wählen.

Natürlich können Sie die Elemente eines Arrays auch sortieren. Wenn Sie z.B. eine Liste mit Namen haben und diese Namen sollen aufsteigend sortiert sein, dann verwenden Sie am einfachsten ein Array, und Sie können jedes Element einzeln ansprechen und bearbeiten. Den Artikel zum Sortieren gibt es natürlich auch schon: Sortieren von Arrays in VBScript.

Schlußbemerkung

Sie haben heute gelernt, wie man statische und dynamische Arrays deklariert, und wie man mit mit mehrdimensionalen Arrays umgeht. Ein weiterer Artikel wird sich mit den wichtigsten Array-Funktionen ausführlich beschäftigen.