In einem der vorherigen Videos haben wir uns bereits mit den Grundzügen der Variablen
beschäftigt. Hier ein ganz einfaches Beispiel. Hier wird eine Variable X generiert. Dem X wird
dann in der "setup" Funktion ein zufälliger Wert zwischen 0 und 400 zugewiesen und dieser wird dann
in der "draw" Schleife benutzt. Dadurch das wir sozusagen hier ganz am Anfang diesen zufälligen
Wert definieren, können wir sozusagen danach unsere "draw"-Schleife laufen lassen, ohne dass
dann sozusagen jedes mal eine andere Position auftaucht, sondern nur dann wenn ich das ganze
abspeicher, wird ein neuer random-Wert generiert und sonst bleibt das Ganze an der selben Position
stehen. Das ist ganz schön solche einzelnen Variablen zu definieren, wenn wir wirklich
auch nur einzelne Objekte haben. Aber stellen wir uns vor, wir wollen jetzt hunderte Punkte auf der
x-Achse zeichnen, wo dann entsprechend einzelne Werte durch random generiert werden. Dann wäre es
jetzt natürlich extrem anstrengen, wenn wir jetzt hier irgendwie let x1 =, let x2=... und das Ganze
dann bis 100, 200, 300 durchdefinieren müssten. Um sowas abbilden zu können, gibt es einen weiteren
Variablentypen. Und das sind die sogenannten Arrays. Arrays sind Listen-Container in die wir
ganz viele Sachen reinwerfen können. Also lasst uns für das X jetzt hier ein Array anlegen. Das
Array definieren wir einfach indem wir so zwei eckige Klammern hier anlegen. Das ist sozusagen
die Initiierung für ein Array. Man kann das Ganze auch so schreiben, dass findet ihr vielleicht auch
manchmal im Internet als Beispiel. Aber es ist halt die längere Schreibweise. Einfacher geht
es wenn wir das einfach so macht. Wenn wir jetzt was in X einfügen wollen, in unserer
Array. Dann ist das ein bisschen komplizierter. Weil wir können nicht einfach = schreiben, weil,
ihr könnt euch vorstellen, dass es eine Liste ist und wir müssen im System ja sagen wo es eingefügt
werden soll. Wenn wir einfach sozusagen zu unserer Liste eins hinzufügen wollen, können wir einfach
sagen "push" und können dann in der Klammer den Wert angeben den wir hinzufügen wollen.
Und wenn wir jetzt auf diesen Wert wieder zugreifen wollen, dann müssen wir dem
System auch sagen welchen Wert wir haben wollen. Und dafür gibt man wieder diese zwei
eckigen Klammern an und hierin gibt man jetzt den "index", also die Position des Wertes an,
den wir abrufen wollen. In unserem Fall ist nur ein Wert drin, deswegen sagen wir den ersten Wert.
Und bei solchen Arrays fängt der Index immer bei 0 an. Der erste Wert hat also den Index 0, der
zweite 1 usw. Wenn ich jetzt auf speichern drücke, sehen wir, dass das ganze wieder funktioniert.
Und weil wir jetzt halt so eine Liste haben, können wir nicht nur einen Wert darin speichern,
sondern ganz viele darin speichern. Wenn ich jetzt hier zum Beispiel eine Liste anlege.
Mache einfach Variable "c" für "counter". Fügen 1 nach jeder Runde hinzu und sagen: hundert Mal soll
jeweils ein random-Wert hinzugefügt werden. Und wenn ich das Ganze dann zeichnen will, kann ich
einfach sagen 40/0 und so lange "c" kleiner.. Und jetzt kann ich zum Beispiel damit ich sozusagen
diese hundert an einer Stelle definieren muss. Hat unsere Liste ein zusätzliches Attribut
nämlich die Länge. Wir können einfach sagen: x.length und darüber bekommen wird sozusagen
die aktuelle Länge unserer Liste zurück. Also sagen wir dem System jetzt:wir fangen bei 0 an
und dann soll "c" so lange hoch gezähllt werden, solange "c" kleiner als die Länge von "x" ist.
Und da können wir dann hier unseren "circle" zeichnen. Und als Index benutzen wir jetzt
einfach das "c", das immer um eins hochgezählt wird. Also in der ersten Runde ist es die 0,
i der nächsten Runde eins, zwei, drei und so weiter. Und darüber können wir sozusagen von
dieser Liste die einzelnen Werte abrufen. Und jetzt sehen wir sozusagen wie hier
sozusagen für jeden Wert sozusagen ein unterschiedlicher X-Wert abgerufen wird. Es
können aber nicht nur sozusagen eindimensionale Arrays sein. Also einfach nur eine Liste,
sondern wir können sogar Arrays in Arrays anlegen. Dafür benenne ich
das jetzt einfach mal um, damit dass ein bisschen übersichtlicher ist. Und
nennen das einfach "coordinates" und in unsere "coordinates" fügen wir jetzt ein Array ein.
Dafür machen wir einfach hier wieder so eine eckige Klammer.
Und fügen jetzt einfach zwei Werte in diesem Array ein. Also fügen jetzt ein Array,
in dem zwei zufällige Werte nämlich die X und die Y-Koordinaten drin stehen. Und das Ganze
können wir dann hier unten wieder abrufen. Und jetzt sagen wir "coordinates"... Und
weil das Ganze ja mehrdimensional ist, müssen wir dem System jetzt sagen welches Objekt in
der Liste der Arrays willst du haben, dafür nehmen wir jetzt "c" und dann wollen wir erst
den ersten Wert aus dem verschachtelten Array haben und dann den zweiten Wert,
die wir dann sozusagen für x/y benutzen können. Und jetzt sehen wir sozusagen,
wie wir aus dem im "setup" generierten Array, mit dem Unter-Array diese ganzen zufälligen
Werte hier abgerufen werden. Am Anfang habt ihr vielleicht noch keine direkte Verwendung
für Arrays. Aber später, wenn ihr komplexere Layouts macht und bestimmte Einstellungen,
bestimmte Koordinaten irgendwo speichern müsst, dann werden diese Arrays total wichtig,
um sozusagen dort ganz viele Informationen ablegen zu können und diese auch wieder abrufen zu können.