Array-Erstellung

Array.of()

Verwendet alle Werte in den Argumenten als Elemente, um ein Array zu bilden.

console.log(Array.of(1, 2, 3, 4)); // [1, 2, 3, 4] //Argumentwerte können unterschiedliche Typen haben. console.log(Array.of(1, '2', true)); // [1, '2', true] //Gibt ein leeres Array zurück, wenn keine Argumente übergeben werden. console.log(Array.of()); // []

Array.from()

Wandelt ein array-ähnliches Objekt oder iterierbares Objekt in ein Array um.

//Wenn das Argument ein Array ist, wird ein Array zurückgegeben, das mit dem ursprünglichen Array identisch ist. console.log(Array.from([1, 2])); // [1, 2] //Wenn das Argument leere Slots enthält. console.log(Array.from([1, , 3])); // [1, undefined, 3]

Parameters

Array.from(arrayLike[, mapFn[, thisArg]])

Der Rückgabewert ist das konvertierte Array.

arrayLike

Das array-ähnliche Objekt oder iterierbare Objekt, das konvertiert werden soll.

console.log(Array.from([1, 2, 3])); // [1, 2, 3]

mapFn

Optional. Die map-Funktion, wird verwendet, um jedes Element zu verarbeiten; die verarbeiteten Elemente werden in das Array eingefügt.

console.log(Array.from([1, 2, 3], (n) => n * 2)); // [2, 4, 6]

thisArg

Optional. Wird verwendet, um das `this`-Objekt anzugeben, wenn die map-Funktion ausgeführt wird.

let map = { do: function(n) { return n * 2; } } let arrayLike = [1, 2, 3]; console.log(Array.from(arrayLike, function (n){ return this.do(n); }, map)); // [2, 4, 6]

Array-ähnliche Objekte

Ein array-ähnliches Objekt muss eine `length`-Eigenschaft besitzen, und die Element-Eigenschaftsnamen müssen numerisch oder in Zahlen konvertierbare Strings sein.

let arr = Array.from({ 0: '1', 1: '2', 2: 3, length: 3 }); console.log(arr); // ['1', '2', 3] //Wenn keine `length`-Eigenschaft vorhanden ist, wird ein leeres Array zurückgegeben. let array = Array.from({ 0: '1', 1: '2', 2: 3, }); console.log(array); // [] //Wenn die Eigenschaftsnamen der Elemente nicht numerisch sind und nicht in Zahlen umgewandelt werden können, wird ein Array der Länge `length` mit Elementwerten `undefined` zurückgegeben. let array1 = Array.from({ a: 1, b: 2, length: 2 }); console.log(array1); // [undefined, undefined]

Konvertieren von iterierbaren Objekten

Konvertieren von Map

let map = new Map(); map.set('key0', 'value0'); map.set('key1', 'value1'); console.log(Array.from(map)); // [['key0', 'value0'],['key1', // 'value1']]

Konvertieren von Set

let arr = [1, 2, 3]; let set = new Set(arr); console.log(Array.from(set)); // [1, 2, 3]

Strings umwandeln

let str = 'abc'; console.log(Array.from(str)); // ["a", "b", "c"]

Erweiterte Methoden

Find

find()

Findet ein Element im Array, das die Bedingung erfüllt; wenn mehrere passende Elemente vorhanden sind, wird das erste zurückgegeben.

let arr = Array.of(1, 2, 3, 4); console.log(arr.find(item => item > 2)); // 3 //Leere Slots im Array werden als `undefined` behandelt. console.log([, 1].find(n => true)); // undefined

findIndex()

Findet den Index eines Elements im Array, das die Bedingung erfüllt; wenn mehrere passende Elemente vorhanden sind, wird der Index des ersten zurückgegeben.

let arr = Array.of(1, 2, 1, 3); //Parameter 1: Callback-Funktion //Parameter 2 (optional): gibt den `this`-Wert in der Callback-Funktion an. console.log(arr.findIndex(item => item == 2)); // 1 //Leere Slots im Array werden als `undefined` behandelt. console.log([, 1].findIndex(n => wahr)); //0

Füllen

fill()

Füllt Array-Elemente innerhalb eines angegebenen Indexbereichs mit einem einzelnen angegebenen Wert.

let arr = Array.of(1, 2, 3, 4); //Parameter 1: der Wert, mit dem gefüllt werden soll //Parameter 2: der Startindex zum Füllen //Parameter 3 (optional): der Endindex zum Füllen, standardmäßig das Ende des Arrays. console.log(arr.fill(0,1,2)); // [1, 0, 3, 4]

copyWithin()

Ändert Array-Elemente innerhalb eines angegebenen Indexbereichs in die Elemente aus einem anderen angegebenen Indexbereich desselben Arrays.

//Parameter 1: der Startindex, der geändert werden soll //Parameter 2: der Startindex der Daten, mit denen überschrieben werden soll //Parameter 3 (optional): der Endindex der Daten, mit denen überschrieben werden soll, standardmäßig das Ende des Arrays. console.log([1, 2, 3, 4].copyWithin(0,2,4)); // [3, 4, 3, 4] //Ein negativer Parameter 1 gibt an, dass vom Ende gezählt wird. console.log([1, 2, 3, 4].copyWithin(-2, 0)); // [1, 2, 1, 2] console.log([1, 2, ,4].copyWithin(0, 2, 4)); // [, 4, , 4]

Iteration

entries()

Iteriert über Schlüssel-Wert-Paare.

for(let [key, value] of ['a', 'b'].entries()){ console.log(key, value); } // 0 "a" // 1 "b" //Verwendet keine for...of-Schleife. let entries = ['a', 'b'].entries(); console.log(entries.next().value); // [0, "a"] console.log(entries.next().value); // [1, "b"] //Array enthält leere Slots. console.log([...[,'a'].entries()]); // [[0, undefined], [1, "a"]]

keys()

Iteriert über Schlüssel.

for(let key of ['a', 'b'].keys()){ console.log(key); } // 0 // 1 //Array enthält leere Slots. console.log([...[,'a'].keys()]); // [0, 1]

values()

Iteriert über Werte.

for(let value of ['a', 'b'].values()){ console.log(value); } // "a" // "b" //Array enthält leere Slots. console.log([...[,'a'].values()]); // [undefined, "a"]

Enthält

includes()

Ob das Array den angegebenen Wert enthält.

Hinweis: Zu unterscheiden von den `has`-Methoden von Set und Map; die `has`-Methode von Set dient zum Auffinden von Werten; die `has`-Methode von Map dient zum Auffinden von Schlüsseln.

//Parameter 1: der angegebene Wert, der auf Enthaltensein geprüft werden soll [1, 2, 3].includes(1); // true //Parameter 2: optional, der Startindex für die Suche, Standardwert ist 0. [1, 2, 3].includes(1, 2); // false //Prüfung auf Enthaltensein für NaN [1, NaN, 3].includes(NaN); // true

Verschachtelte Arrays in eindimensionale Arrays abflachen

flat()

console.log([1 ,[2, 3]].flat()); // [1, 2, 3] //Geben Sie die Anzahl der zu abflachenden Verschachtelungsebenen an. console.log([1, [2, [3, [4, 5]]]].flat(2)); // [1, 2, 3, [4, 5]] //Egal, wie viele Ebenen verschachtelt sind. console.log([1, [2, [3, [4, 5]]]].flat(Infinity)); // [1, 2, 3, 4, 5] //Überspringt automatisch leere Slots. console.log([1, [2, , 3]].flat());<p> // [1, 2, 3]
flatMap()

Verarbeitet zunächst jedes Element im Array und führt dann die Methode flat() auf dem Array aus.

//Parameter 1: eine Callback-Funktion; diese Callback-Funktion kann 3 Parameter akzeptieren: das aktuelle Element, den Index des aktuellen Elements und das ursprüngliche Array. //Parameter 2: legt den `this`-Wert in der Callback-Funktion fest. console.log([1, 2, 3].flatMap(n => [n * 2])); // [2, 4, 6]

ArrayBuffer

Ein ArrayBuffer ist ein Abschnitt von Adressen im Speicher.

Die Grundlage typisierter Arrays.

Die tatsächliche Anzahl von Bytes wird bei der Erstellung festgelegt. Danach können nur die darin enthaltenen Daten geändert werden; seine Größe kann nicht geändert werden.

Erstellen eines ArrayBuffer

Erstellt über:

let buffer = new ArrayBuffer(10); console.log(buffer.byteLength); // 10Slicing eines vorhandenen ArrayBufferlet buffer = new ArrayBuffer(10); let buffer1 = buffer.slice(1, 3); console.log(buffer1.byteLength); // 2

View

Eine View ist eine Schnittstelle, die zum Arbeiten mit Speicher verwendet wird.

Eine View kann mit einem ArrayBuffer oder einer Teilmenge der Bytes des Puffers arbeiten und liest und schreibt Daten gemäß einem der numerischen Datentypen.

Der DataView-Typ ist eine generische ArrayBuffer-View, die alle 8 numerischen Datentypen unterstützt.

Erstellung:

//Standardmäßig kann eine DataView mit dem gesamten Inhalt des ArrayBuffer arbeiten. let buffer = new ArrayBuffer(10); dataView = new DataView(buffer); dataView.setInt8(0,1); console.log(dataView.getInt8(0)); // 1 //Geben Sie den Bytebereich an, auf dem das DataView-Objekt arbeiten kann, indem Sie den Offset (Parameter 2) und die Länge (Parameter 3) festlegen. let buffer1 = new ArrayBuffer(10); dataView1 = new DataView(buffer1, 0, 3); dataView1.setInt8(5,1); // RangeError

Typisierte Arrays

Ansichten eines bestimmten Typs für den ArrayBuffer.

Sie können die Verwendung eines bestimmten Datentyps erzwingen, anstatt ein generisches DataView-Objekt zu verwenden, um auf dem ArrayBuffer zu arbeiten.

Erstellung

Aus einem ArrayBuffer generiert.

let buffer = new ArrayBuffer(10), view = new Int8Array(buffer); console.log(view.byteLength); // 10

Über den Konstruktor.

let view = new Int32Array(10); console.log(view.byteLength); // 40 console.log(view.length); // 10 //Wenn keine Parameter übergeben werden, ist die Standardlänge 0. //In diesem Fall wird kein Speicher für den ArrayBuffer zugewiesen, und das erstellte typisierte Array kann nicht zum Speichern von Daten verwendet werden. let view1 = new Int32Array(); console.log(view1.byteLength); // 0 console.log(view1.length); // 0 //Zulässige Parameter umfassen typisierte Arrays, iterierbare Objekte, Arrays und array-ähnliche Objekte. let arr = Array.from({ 0: '1', 1: '2', 2: 3, length: 3 }); let view2 = new Int16Array([1, 2]), view3 = new Int32Array(view2), view4 = new Int16Array(new Set([1, 2, 3])), view5 = new Int16Array([1, 2, 3]), view6 = new Int16Array(arr); console.log(view2 .buffer === view3.buffer); // false console.log(view4.byteLength); // 6 console.log(view5.byteLength); // 6 console.log(view6.byteLength); // 6

Zu beachtende Punkte

Die `length`-Eigenschaft ist nicht schreibbar. Wenn Sie versuchen, diesen Wert zu ändern, wird der Vorgang im nicht strikten Modus stillschweigend ignoriert, und im strikten Modus wird ein Fehler ausgelöst.

let view = new Int16Array([1, 2]); view.length = 3; console.log(view.length); // 2

Typisierte Arrays können mit entries(), keys() und values() iteriert werden.

let view = new Int16Array([1, 2]); for(let [k, v] of view.entries()){ console.log(k, v); } // 0 1 // 1 2

Methoden wie find() können ebenfalls auf typisierten Arrays verwendet werden, aber die Methoden typisierter Arrays prüfen zusätzlich, ob der numerische Typ sicher ist, und verwenden außerdem Symbol.species, um zu bestätigen, dass der Rückgabewert der Methode ein typisiertes Array und kein normales Array ist. Die Methode concat() kann nicht auf typisierten Arrays verwendet werden, da das Ergebnis der Zusammenführung zweier typisierter Arrays ungewiss ist; außerdem sind, da die Größe eines typisierten Arrays nicht geändert werden kann, Methoden, die die Größe eines Arrays ändern können, wie splice(), nicht auf typisierte Arrays anwendbar.

let view = new Int16Array([1, 2]); view.finde((n) > 1); // 2

Alle typisierten Arrays enthalten statische Methoden of() und from(), deren Verhalten ähnlich wie Array.of() bzw. Array.from() ist. Der Unterschied besteht darin, dass die Methoden typisierter Arrays ein typisiertes Array zurückgeben, während die normalen Array-Methoden ein normales Array zurückgeben.

let view = Int16Array.of(1, 2); console.log(view instanceof Int16Array); // true

Typisierte Arrays sind keine normalen Arrays und erben nicht von Array.

let view = new Int16Array([1, 2]); console.log(Array.isArray(view)); // false

Typisierte Arrays fügen die Methoden set() und subarray() hinzu. Die Methode set() wird verwendet, um andere Arrays in ein vorhandenes typisiertes Array zu kopieren, und subarray() wird verwendet, um einen Teil eines vorhandenen typisierten Arrays zu extrahieren, um ein neues typisiertes Array zu bilden.

//set-Methode //Parameter 1: ein typisiertes Array oder ein normales Array. //Parameter 2: optional, der Offset, die Position, an der das Einfügen von Daten beginnt, Standardwert ist 0. let view= new Int16Array(4); view.set([1, 2]); view.set([3, 4], 2); console.log(view); // [1, 2, 3, 4] //subarray-Methode //Parameter 1: optional, die Startposition. //Parameter 2: optional, die Endposition (die Endposition nicht eingeschlossen). let view= new Int16Array([1, 2, 3, 4]), subview1 = view.subarray(), subview2 = view.subarray(1), subview3 = view.subarray(1, 3); console.log(subview1); // [1, 2, 3, 4] console.log(subview2); // [2, 3, 4] console.log(subview3); // [2, 3]

Spread-Operator

Arrays kopieren

let arr = [1, 2], arr1 = [...arr]; console.log(arr1); // [1, 2] //Das Array enthält leere Slots. let arr2 = [1, , 3], arr3 = [...arr2]; console.log(arr3); [1, undefined, 3]

Arrays zusammenführen

console.log([...[1, 2],...[3, 4]]); // [1, 2, 3, 4]