Arrays

Arrays sind dynamisch und erweiterbar (Objekte)

Index beginnt bei 0
unterschiedliche Typen als Inhalt möglich
Länge über .length auslesbar
Zugriff auf Elemente über [index]

Erzeugung mit new Array() oder einem Array-Literal

initiale Größe kann optional angegeben werden
Array kann bei Erzeugung direkt initialisiert werden

Iterieren über alle Elemente mit foreach-Schleife
for (let e of arr) { ... }

Beispiel: Iterieren

let arr = [ 'A', 'B', 'C', 'D' ];

for (let e of arr) {
  log(e);
}

Beispiel: Dynamisches Array

let a1 = new Array();
a1[0] = "Hallo";
a1[1] = 42;

log(a1.length);

a1[22] = 23;

log(a1);
log(a1.length);

Beispiel: Wachsen eines Arrays

let a2 = new Array(3);
a2[0] = "Hallo";
a2[1] = 42;

log(a2.length);

a2[12] = 23;

log(a2);
log(a2.length);

Beispiel: Array initialisieren

// Array direkt initialisieren
let a3 = new Array("Hallo", 24, 23);

// Array Literale
let leer = [];
let zahlen = [ "eins", "zwei", "drei" ];

log(leer[0]);
log(zahlen[1]);

Beispiel: Löschen von Elementen

// Löschen von Elementen (Lücke bleibt)
let zahlen = [ "eins", "zwei", "drei" ];
delete zahlen[1];

log(zahlen);
log(zahlen.length);

// Entfernen von Elementen (ohne Lücke)
let zahlen = [ "eins", "zwei", "drei" ];
zahlen.splice(1, 1);

log(zahlen);
log(zahlen.length);

Beispiel: Elemente anhängen

// Anhängen von Elementen
let a5 = [ "a", "b", "c" ];

a5[a5.length] = "d";
log(a5);

a5.push("e");
log(a5);

Assoziatives Array

Besonderes Array mit String als Index

unterschiedliche Typen als Inhalt möglich
ähnlich einer Map in Java

Verarbeitung

Erzeugung mit new Array() oder Literal { ... }
Auslesen eines Elements über ["Index"]
Iterieren über alle Keys mit foreach-Schleife
for (let e in arr) { ... }

Beispiel: Assoziatives Array

let a4 = new Array();
a4["go"] = "gehen";
a4["walk"] = "gehen";
a4["sleep"] = "schlafen";

log(a4["go"]);

for (let e in a4 ) { log(e + ": " + a4[e]); }

Beispiel: Array-Literal

let a5 = {
  "go": "gehen",
  "walk" : "gehen",
  "sleep" : "schlafen" };

for (let e in a5 ) { log(e + ": " + a5[e]);  }

foreach-Schleife

Achtung: Es gibt zwei Arten von foreach-Schleifen

for (let e of arr)
Wird für indizierte Arrays verwendet und liefert die Elemente
for (let e in arr)
Wird für assoziative Arrays (und Objekte) verwendet und liefert die Namen der Keys/Properties
Index und Wert bei indizierte Arrays mit
for (let [ k, v ] of arr.entries())

Spread-Operator

Der Spread-Operator ... zerlegt ein Array in einzelne Elemente

Inkludieren von Arrays in andere
let b = [1, ...a, 2];
Kopieren von Arrays
let b = [...a];
Zerlegen von Strings in Zeichen
let digits = [..."0123456789"];
Aufrufen von Funktionen mit Arrays
add(...values)

forEach

forEach-Methode

anstatt mit for kann man auch über die forEach-Methode gehen
es findet eine interne Iteration statt

let a = [ 'a', 'b', 'c' ];
a.forEach(e => log(e));

map

Mit der map-Methode wird jedes Element auf ein anderes gemappt

let a = [ 1, 2, 3, 4 ];
let b = a.map(x => x*x);

log(b);

reduce

Als Gegenstück zu map reduziert reduce die Werte mehrerer Elemente auf ein Element
arr.reduce(fun, start_value)

let r = [ 1, 2, 3, 4 ];
let s = r.reduce((sum, x) => sum + x, 0);

log(s);

Weitere Methoden auf Arrays

Funktion	Erklärung
`filter(pf)`	Neues Array mit den Elementen für die `pf` `true` geliefert hat
`find(pf)`	Liefert das erste Element, für das `pf` `true` geliefert hat
`findIndex(pf)`	Liefert den Index des ersten Elements, für das `pf` `true` geliefert hat
`indexOf(e)`	Sucht Elemente und gibt den Index des ersten Treffers zurück
`lastIndexOf(e)`	Sucht Elemente (von hinten) und gibt den Index des ersten Treffers zurück
`every(pf)`	Wendet die Funktion `pf` auf alle Elemente an und verknüpft das Ergebnis per AND
`some(pf)`	Wendet die Funktion `pf` auf alle Elemente an und verknüpft das Ergebnis per OR
`includes(e)`	Testet, ob ein Element enthalten ist

Beispiel: Methoden auf Arrays

let a = [ 1, 2, 3, 4, 5, 6, 7, 8 ];
let even = a.filter(e => e % 2 == 0); // -> [ 2, 4, 6, 8 ]

a.find(e => e % 4 == 0);              // -> 4
a.findIndex(e => e % 4 == 0);         // -> 3
a.indexOf(4);                         // -> 3
a.every(e => e < 10);                 // -> true
a.some(e => e > 3);                   // -> true
a.includes(8);                        // -> true

Weitere Methoden auf Arrays

Funktion	Erklärung
`push(...vals)`	Fügt Elemente hinten an
`pop()`	Nimmt Elemente hinten weg
`unshift(...vals)`	Fügt Elemente vorne an
`shift()`	Nimmt Elemente vorne weg
`slice(start, end)`	Erzeugt einen Ausschnitt
`splice(start, end, ...vals)`	Entfernt Elemente und fügt (optional) an deren Position neue ein
`fill(...)`	Füllt das Array mit einem Wert
`sort()`	Sortiert das Array und verändert das Objekt selbst
`reverse()`	Dreht die Reihenfolge um
`join(t)`	Wandelt das Array in einen String um, mit `t` als Trennzeichen
`flat(lvl)`	Klopft über `lvl`-Ebenen verschachtelte Arrays flach
`concat(...vals)`	Erzeugt ein neues Array mit den zusätzlichen Elementen am Ende

Beispiel: Methoden auf Arrays

let a = [ 1, 2 ];

a.push(3, 4, 5);   // -> [ 1, 2, 3, 4, 5 ]
a.pop();           // -> 5
a.unshift(0);      // -> [ 0, 1, 2, 3, 4 ]
a.shift();         // -> 0

a.slice(1, 2);     // -> 2
a.splice(1, 2, 9);
log(a);            // -> [ 1, 9, 4 ]
a.reverse();       // -> [ 4, 9, 1 ]
a.sort();          // -> [ 1, 4, 9 ]
a.join('|');       // -> '1|4|9'

Besonderheiten von JavaScript-Arrays

Technisch gibt es nur Objekte, Arrays existieren in JavaScript nicht
Normale Arrays sind Assoziative Arrays: Index → String → Key des Arrays
Assoziative Arrays sind Objekte und die Keys sind die Namen der Properties

let a = [];
a['10'] = 'e10';
a[9] = 'e9';

log(a[10]); // -> e10
log(a['9']); // -> e9

let o = { a: 23, b: 42 };

log(o.a);    // -> 23
log(o['b']); // -> 42

o['c'] = 7;
log(o.c);   // -> 7