So erstellen Sie ein mehrdimensionales Javascript-Array. Entfernen von Musterteilen. Hinzufügen von benutzerdefinierten Eigenschaften zu Arrays

Sowohl in JavaScript als auch in anderen Programmiersprachen werden verschiedene Methoden verwendet, um mit Arrays zu arbeiten.

Methoden machen es einfach, Logik zu erstellen und in einem Skript zu implementieren.

Unten sind die grundlegende Methoden für die Arbeit mit Arrays in JS.

drücken

Die Methode push() fügt am Ende des Arrays einen Wert hinzu.

Lassen Sie arr =; Anr.-Druck (312); Konsole.log (arr); // →

Pop

Die Methode pop() entfernt das letzte Element aus dem Array oder gibt seinen Wert zurück.

Lassen Sie arr =; arr.pop (); Konsole.log (arr); // →

Mit der Möglichkeit, den Wert des letzten Elements des Arrays abzurufen, können wir als Beispiel das Bildformat abrufen:

Lassen Sie img = "https://example.com/img/name.png"; let format = img.split (".").pop(); Konsole.log (Format); // → png console.log (img.split (".")); // → ["https: // Beispiel", "com / img / name", "png"]

entschalten

Die Methode unshift() fügt am Anfang des Arrays ein Element hinzu.

Lassen Sie arr =; arr.unshift (312); Konsole.log (arr); // →

Schicht

Die Methode shift() entfernt das erste Element aus dem Array.

Lassen Sie arr =; Anr.Verschiebung (); Konsole.log (arr); // →;

Sie müssen verstehen, dass bei Verwendung der Methoden shift und unshift jedes Element des Arrays seinen Index ändert. Dies kann die Programmausführung verlangsamen, wenn das Array lang ist.

Teilt

Die Methode split() wird verwendet, um einen String in ein Array umzuwandeln. Split teilt eine Zeichenfolge durch den angegebenen Parameter.

Let str = "Anya, Masha, Sasha, Dasha"; // dies ist ein String let arr = str.split (","); Konsole.log (arr); // → ["Anya", "Masha", "Sasha", "Dasha"] ist ein Array

beitreten

Die Methode join() verbindet die Elemente eines Arrays zu einem String, getrennt durch das im Parameter angegebene Trennzeichen.

Let arr = ["Notpad ++", "Sublime", "VSCode"]; // Dies ist ein Array let str = arr.join (","); console.log ("Editoren für den Code:" + str); // → "Editoren für Code: Notpad ++, Sublime, VSCode"

Scheibe

Die Methode Slice() erstellt ein neues Array, in das sie Elemente aus der Quelle kopiert, beginnend mit dem Element mit dem Index des ersten an die Methode übergebenen Parameters, bis zum Element mit dem Index des zweiten Parameters.

Beispiel: Slice (3, 7) gibt Elemente mit den Indizes 3, 4, 5, 6 zurück. Das Element mit dem Index 7 wird nicht in das Array aufgenommen.

Wenn ein Parameter mit einem negativen Wert an Slice() übergeben wird, gibt es ein neues Array mit der im Parameter angegebenen Anzahl von Elementen zurück, das jedoch bereits vom Ende des ursprünglichen Arrays genommen wurde.

Die Slice-Methode ändert das ursprüngliche Array nicht.

Hier sind einige Beispiele für die Funktionsweise der Slice()-Methode:

Sei arr = ["A", "B", "C", "D", "E", "F", "G"]; // Gibt ein Array zurück, das Elemente mit Indizes von 2 bis 5 enthält. console.log (arr.slice (2, 5)); // → ["C", "D", "E"] // Liefert ein neues Array mit Elementen mit Indizes von 3 bis arr.length console.log (arr.slice (3)); // → ["D", "E", "F", "G"] // Gibt eine Kopie des ursprünglichen Arrays zurück console.log (arr.slice ()); // → ["A", "B", "C", "D", "E", "F", "G"] // Liefert ein neues Array bestehend aus letzte drei Elemente der ursprünglichen Konsole.log (arr.slice (-3)); // → ["E", "F", "G"]

spleißen

Die Methode splice() modifiziert den Inhalt des Arrays, indem vorhandene Elemente entfernt und/oder neue hinzugefügt werden.

Syntax:

Array.splice (start, deleteCount [, item1 [, item2 [, ...]]])

Parameter:

• Anfang- Der Index, ab dem mit der Änderung des Arrays begonnen werden soll. Wenn er größer als die Länge des Arrays ist, wird der reale Index auf die Länge des Arrays gesetzt. Wenn negativ, gibt den Index des Elements vom Ende an.
• deleteCount- Eine ganze Zahl, die die Anzahl der alten Elemente angibt, die aus dem Array entfernt wurden. Wenn deleteCount 0 ist, werden keine Elemente gelöscht. In diesem Fall müssen Sie mindestens einen neuen Artikel angeben. Wenn deleteCount mehr menge Elemente, die im Array verbleiben, beginnend bei Indexstart, dann werden alle Elemente bis zum Ende des Arrays entfernt.
• ArtikelNr- Optionale Parameter. Elemente, die dem Array hinzugefügt werden sollen. Wenn Sie kein Element angeben, entfernt splice() einfach die Elemente aus dem Array.

Rückgabewert

Beschreibung

Wenn die Anzahl der angegebenen eingefügten Elemente von der Anzahl der entfernten Elemente abweicht, ändert das Array die Länge nach dem Aufruf.

Let arr = [Barça, Miner, Manchester United, Mailand, Real Madrid, Ajax, Juventus]; let nax = arr.spleiß (2, 3); arr.spleiß (2, 3); Konsole.log (nax); // → [Manchester United, Mailand, Real Madrid] console.log (arr); // → [Barca, Miner] arr.splice (1, 0, Zenit, CSKA, Spartak); Konsole.log (arr); // → [Barca, Zenit, CSKA, Spartak, Shakhtar]

umkehren

Die reverse()-Methode kehrt die Reihenfolge der Array-Elemente um. Dadurch wird das erste Element des Arrays zum letzten und das letzte Element zum ersten.

Lassen Sie arr =; console.log (arr.reverce ()); // → console.log ("["Alice", "BG", "GO", "DDT"]. Reverce ()); // → ["DDT", "GO", "BG", "Alice"]

Karte

Die Methode map() iteriert über die Elemente des Arrays, führt die angegebenen Aktionen mit ihnen aus und gibt eine Kopie des Arrays mit den geänderten Elementen zurück.

Fügen Sie im folgenden Beispiel zu jedem Element des Arrays den Wert des Index dieses Elements hinzu (7 + 0, 2 + 1, 15 + 2, 4 + 3, 31 + 4):

Lassen Sie arr =; let testMap = arr.map ((Element, Index) => Element + Index); console.log (testMap); //

oder zum Beispiel multiplizieren wir jeden Wert des Arrays mit 12

Lassen Sie arr =; let testMap = arr.map (a => a * 12); console.log (testMap); // →

Filter

Die Methode filter() wird verwendet, um Arrays zu filtern. Es durchläuft das Array und gibt nur die Elemente zurück, die die angegebene Bedingung erfüllen.

Filtern Sie beispielsweise die Werte des Arrays aus den Zahlen und lassen Sie nur diejenigen übrig, die größer als 21 . sind

Lassen Sie arr =; let testFilter = arr.filter (element => element> 21); console.log (testFilter); // →

Bitte beachten Sie, dass 21 nicht im Ergebnis des Arrays enthalten war, da die Bedingung etwas größer als 21 zurückgeben sollte. Damit 21 in das Array eintreten kann, setzen wir die Bedingung auf größer oder gleich: element> = 21

reduzieren

Die Methode Reduce() durchläuft sequentiell die Elemente des Arrays, während das Zwischenergebnis gemäß dem in der Aktionsbedingung der Funktion angegebenen Ergebnis akkumuliert wird. Am Ende gibt es nur einen Wert zurück.

Diese Methode wird häufig verwendet, um die Summe aller Zahlen in einem Array zu ermitteln. Beispiel:

Lassen Sie arr =; let summa = arr.reduce ((acc, element) => acc + element); Konsole.log (summa); // → 370

Sortieren

Die Methode sort() wird verwendet, um die Elemente eines Arrays nach den angegebenen Parametern zu sortieren.

Beispiel - Nehmen Sie ein Array von Zahlen und sortieren Sie sie in aufsteigender Reihenfolge:

Lassen Sie arr =; let testSortArr = arr.sort ((a, b) => a - b); console.log (testSortArr); // →

beinhaltet

Die Methode include() bestimmt, ob das Array ein bestimmtes Element enthält, und gibt abhängig davon true oder false zurück.

Ein Beispiel für die Verwendung von include().

Hier ist ein logischer Ausdruck:

Lassen Sie Tier = "Hund"; if (Tier == "Katze" || Tier == "Hund" || Tier == "Löwe" || Tier == "Pferd") (// ........)

mit der Methode include kann wie folgt geschrieben werden:

Lassen Sie Tier = "Hund"; const Animals = ["Katze", "Hund", "Löwe", "Pferd"]; if (animals.includes (Tier)) (// ...........)

Erfahren Sie, wie Sie Arrays in js indizieren, ihre Elemente entfernen und hinzufügen.

Ein Array in JavaScript ist ein globales Objekt zum Speichern einer Liste von Werten.

Sie ähnelt anderen Variablen darin, dass sie jede Art von Daten speichern kann. Ein Array hat jedoch einen wichtigen Unterschied zu einer Variablen: Es kann mehr als ein Element gleichzeitig speichern.

Ein Array ist eine geordnete Sammlung von Werten. Jeder Wert wird als Element bezeichnet und hat eine eigene Zahl, die als Index bezeichnet wird.

Ein Element innerhalb eines Arrays kann einen beliebigen Typ haben. Außerdem können die Elemente eines Arrays sein verschiedene Typen: Zahlen, Strings, Boolesche Werte und sogar Objekte oder andere Arrays.

Die Reihenfolge der Array-Elemente ist 0-basiert. Es stellt sich heraus, dass das Array immer einen Index-Offset um eins hat: das erste Element hat den Index 0, das zweite 1 usw.

Hier ist ein Beispiel für ein Array mit Elementen verschiedener Typen:

Erstellen (deklarieren) Sie ein Array

Arrays sind sehr praktisch, da sie so viele Daten wie nötig speichern können. Die maximal mögliche Größe eines js -Arrays beträgt 2 32 Elemente.

Wir müssen JavaScript mitteilen, dass wir ein Array erstellen möchten. Dafür gibt es zwei Möglichkeiten: den Wert in eckigen Klammern oder Stichwort Neu.

Kurznotation: mit eckigen Klammern

Eine durch Kommas getrennte Liste von Werten in eckigen Klammern.

var myArray = ["Jack", "Sawyer", "John", "Desmond"];

Der Inhalt des Arrays wird durch den Inhalt zwischen den eckigen Klammern bestimmt. In diesem Fall wird jeder Wert durch ein Komma getrennt.

Werte werden wie einfache Variablen gesetzt, d. h. Strings müssen in Anführungszeichen usw. deklariert werden.

Um ein leeres Array zu deklarieren, lassen Sie die Klammern leer:

var myArray =;

Lange Notation: Verwenden des Array()-Konstruktors

var lostArray = neues Array ("Jack", "Sawyer", "John", "Desmond"); var twinPeaksArray = neues Array ("Laura", 2, ["Bob", "Leland", "Dale"]);

Das Schlüsselwort new weist JavaScript an, ein neues Array zu erstellen, dessen Werte als Parameter übergeben werden.

Wenn Sie im Voraus wissen, wie viele Elemente Ihr Array haben wird, können Sie diesen Wert sofort an den Konstruktor übergeben.

var myArray = neues Array (80);

Der obige Ausdruck erstellt ein leeres Array von 80 Slots mit undefinierten Werten.

Deklarieren eines leeren Arrays:

var myArray = neues Array ();

Auf Array-Elemente zugreifen

Mit dem Index jedes Elements können Sie mit allen Daten im Array arbeiten und mit dem Operator darauf verweisen:

var myArray = ["Jack", "Sawyer", "John", "Desmond"]; console.log (meinArray); // Gibt „Jack“ console.log (myArray) aus; // Druckt "Desmond"

Ein Array kann mehrere Ebenen haben, dh jedes Element kann selbst ein Array sein. Als Ergebnis erhalten Sie ein zweidimensionales js-Array. Wie können wir auf diese Arrays verweisen, die sich in anderen befinden - " mehrdimensionale Arrays»?

Betrachten wir als Beispiel ein Array, das eine Familie darstellt. Kinder aus dieser Familie werden in einem separaten Array innerhalb des Hauptarrays aufgezeichnet:

var familyArray = ["Marge", "Homer", ["Bart", "Lisa", "Maggie"]];

Das kann man sich so vorstellen:

Um auf die Bedeutung von "Lisa" zu verweisen:

var lisa = familyArray; konsole.log (lisa); // zeigt "Lisa" an

Fast unbegrenzt kann man so weitermachen, was es erlaubt, verschachtelte Datensätze in Arrays zu speichern und über Indizes darauf zuzugreifen.

Hinzufügen von Elementen zu einem Array

Wir haben herausgefunden, wie man mit ihren entsprechenden Indizes auf Array-Elemente zugreift. Auf ähnliche Weise können Sie Elemente hinzufügen (oder ändern), indem Sie beispielsweise Folgendes deklarieren:

var myArray = ["Keith", "Sonne"]; myArray = "Julie"; console.log (meinArray); // Druckt "Kate, Sun, Julia"

Was passiert, wenn ich ein Element mit einem Index deklariere, vor dem keine anderen Elemente sind? Das Array selbst erstellt alle fehlenden Elemente und weist ihnen den Wert undefined zu:

var myArray = ["Keith", "Sonne"]; myArray = "Julie"; console.log (myArray.length); // Gibt "6" console.log (myArray) aus; // Gibt ["Keith", "Sun", undefined, undefined, undefined, "Juliet"] aus

Mit der Eigenschaft length können Sie herausfinden, wie lang das js -Array ist. Im obigen Beispiel gibt es sechs Elemente im Array, und drei davon haben keinen Wert zugewiesen bekommen - sie werden als undefiniert bezeichnet.

Push()-Methode

Mit der Methode push() können Sie einem js-Array ein oder mehrere Elemente hinzufügen. Push() akzeptiert eine unbegrenzte Anzahl von Parametern, die alle am Ende des Arrays hinzugefügt werden.

var myArray = ["Keith", "Sut"]; myArray.push ("Juliet"); // Fügt am Ende des Arrays das Element "Juliet" hinzu myArray.push ("Libby", "Shannon"); // Fügt die Elemente "Libby" und "Shannon" am Ende des Arrays console.log (myaArray ); // Druckt ["Keith", "Sun", "Juliet", "Libby", "Shannon"]

Die unshift()-Methode

Die Methode unshift() funktioniert genauso wie push(), außer dass sie Elemente am Anfang des Arrays hinzufügt.

var myArray = ["Keith", "Sonne"]; myArray.unshift ("Juliet"); // Fügt das Element "Juliet" am Anfang des Arrays hinzu myArray.unshift ("Libby", "Shannon"); // Fügt Libby und Shannon am Anfang des Arrays hinzu console.log (myArray); // Gibt aus ["Libby", "Shannon", "Juliet", "Keith", "Sun"]

Array-Elemente entfernen

Pop () und Shift () Methoden

Die Methoden pop() und shift() entfernen das letzte bzw. das erste Element des Arrays:

var myArray = ["Jack", "Sawyer", "John", "Desmond", "Kate"]; myArray.pop(); // Entfernt das Element "Keith" myArray.shift(); // Entfernt das Jack-Element console.log (myArray); // Druckt ["Sawyer", "John", "Desmond"] aus

Spleiß () Methode

Mit der Methode splice() können Sie Elemente aus einem Array entfernen oder hinzufügen, während Sie den genauen Index der Elemente angeben.

Im folgenden Beispiel fügt die Methode splice() zwei Elemente hinzu, beginnend bei Index 2 ( das heißt, vom dritten Element):

var fruitArray = ["Apfel", "Pfirsich", "Orange", "Zitrone", "Limette", "Kirsche"]; FruitArray.splice (2, 0, "Melone", "Banane"); console.log (fruitArray); // Druckt aus [Apfel, Pfirsich, Melone, Banane, Orange, Zitrone, Limette, Kirsche]

Der erste Parameter der Methode splice() ist der Index. Es zeigt an, an welcher Position Elemente hinzugefügt/entfernt werden sollen. In unserem Beispiel haben wir den Index 2 gewählt ( mit der Bedeutung "orange").

Der zweite Parameter ist die Anzahl der zu entfernenden Elemente. Wir haben einen Wert von 0 angegeben, damit nichts gelöscht wird.

Die folgenden Parameter sind optional. Sie fügen dem Array neue Werte hinzu. In unserem Fall müssen wir "Melone" und "Banane" hinzufügen, beginnend mit Index 2.

Sie können mit Arrays arbeiten mit verschiedene Methoden vom Array-Konstruktor bereitgestellt.

Pop- / Push- und Shift- / Unshift-Methoden

Betrachten Sie die Methoden pop() und push(). Mit diesen Methoden können Sie mit Arrays wie Stapeln arbeiten. Ein Stack ist eine Datenstruktur, in der der Zugriff auf Elemente nach dem LIFO-Prinzip (englisch last in - first out, "last in - first out") organisiert ist. Das Prinzip des Stapels lässt sich mit einem Tellerstapel vergleichen: Um den zweiten von oben zu nehmen, muss der oberste entnommen werden. Wie es funktioniert, ist in der Abbildung dargestellt:

Kommen wir also zurück zur Betrachtung der Methoden push() und pop(). Die Methode push() fügt am Ende des Arrays ein oder mehrere neue Elemente hinzu und gibt seine neue Länge zurück. Die Methode pop() - entfernt das letzte Element des Arrays, verringert die Länge des Arrays und gibt den entfernten Wert zurück. Beachten Sie, dass beide Methoden das Array an Ort und Stelle ändern, anstatt eine modifizierte Kopie davon zu erstellen.

Var foo =; // foo: foo.push (1,2); // foo: Gibt 2 foo.pop() zurück; // foo: Gibt 2 foo.push (3) zurück; // foo: Gibt 2 foo.pop() zurück; // foo: Gibt 3 zurück foo.push(); // foo:] Gibt 2 zurück foo.pop() // foo: Gibt foo.pop() zurück; // foo: Gibt 1 zurück var Fruits = ["pears", "bananas", "apples"]; var gepflückt = früchte.pop (); document.write ("Sie haben meine ausgewählt" + ausgewählt); Versuchen "

Die Methoden shift() und unshift() verhalten sich ähnlich wie pop() und push(), außer dass sie Elemente am Anfang des Arrays einfügen und entfernen. Die Methode unshift() verschiebt vorhandene Elemente zu größeren Indizes, um Platz für neue Elemente zu schaffen, fügt ein oder mehrere Elemente am Anfang des Arrays hinzu und gibt die neue Länge des Arrays zurück. Die Methode shift() entfernt das erste Element des Arrays und gibt seinen Wert zurück, wobei alle nachfolgenden Elemente so verschoben werden, dass sie besetzen Freiraum am Anfang des Arrays.

Varf =; // f: f.unshift (1); // f: Rückgabe: 1 f.unshift (22); // f: Rückgabe: 2 f.shift(); // f: Rückgabe: 22 f.unshift (3,); // f:, 1] Rückgabe: 3 f.shift (); // f: [, 1] Rückgabe: 3 f.shift (); // f: Gibt zurück: f.shift(); // f: Rückgabe: 1

Join-Methode

Die Methode Array.join() wird verwendet, um die Elemente eines Arrays zu einem String zu kombinieren. Ein optionales String-Argument kann an die Methode übergeben werden, das verwendet wird, um die Elemente im String zu trennen. Wenn kein Trennzeichen angegeben ist, ist das Standardtrennzeichen das Komma, wenn die Methode aufgerufen wird.

Var a = ["Wind", "Regen", "Feuer"]; var myVar1 = a.join (); // "Wind, Regen, Feuer" var myVar2 = a.join (","); // "Wind, Regen, Feuer" var myVar3 = a.join ("+"); // "Wind + Regen + Feuer" document.write (myVar1 + "
"+ myVar2 +"
"+ myVar3); Versuchen"

Die Methode Array.join() ist die Umkehrung der Methode String.split(), die ein Array durch Aufteilen einer Zeichenfolge in Stücke erstellt.

Umgekehrte Methode

Die Methode Array.reverse() kehrt die Reihenfolge der Elemente im Array um und gibt das Array mit den neu angeordneten Elementen zurück. Diese Methode erstellt kein neues Array mit neu geordneten Elementen, sondern ordnet sie in einem bereits vorhandenen Array neu an.

Var myArr = ["eins", "zwei", "drei"]; document.write (myArr.reverse ()); Versuchen "

Die concat-Methode

Die Methode Array.concat () erstellt und gibt ein neues Array zurück, das die Elemente des ursprünglichen Arrays enthält, für das die Methode concat () aufgerufen wurde, sequentiell aufgefüllt mit den Werten aller an die Methode concat () übergebenen Argumente. Wenn eines dieser Argumente selbst ein Array ist, werden alle seine Elemente hinzugefügt. Array-Namen werden als Argumente verwendet und in der Reihenfolge angegeben, in der Sie ihre Elemente verketten möchten.

Vara =; a.concat (4, 5) // Gibt a.concat() zurück; // dasselbe - gibt a.concat (,) zurück // Gibt zurück

Sortiermethode

Die Methode Array.sort() sortiert die Elemente des Arrays an Ort und Stelle und gibt das sortierte Array zurück. Wenn die Methode sort() ohne Argument aufgerufen wird, sortiert sie die Elemente des Arrays alphabetisch (wandelt sie zum Vergleich vorübergehend in Zeichenfolgen um). Die Methode sort() kann als Argument eine Vergleichsfunktion annehmen, die die Sortierreihenfolge der Elemente bestimmt.

Var a = ["Kiwi", "Orangen", "Birnen"]; a.sortieren (); var s = a.join (","); // Orangen, Birnen, Kiwi document.write (s); // Beispiel mit Zahlen var myArr =; myArr.sort (); document.write (myArr); // 1,10,2 Probieren Sie es aus "

Sie haben wahrscheinlich erwartet, dass Sie beim Sortieren von Zahlen ein etwas anderes Ergebnis sehen. Diese Art der Sortierung tritt auf, weil die Methode sort() die Elemente sortiert, indem sie sie in Zeichenfolgen konvertiert. Daher haben sie eine String-Reihenfolge - immerhin "10"

Um in einer anderen nicht alphabetischen Reihenfolge zu sortieren, können Sie eine Vergleichsfunktion als Argument an die Methode sort() übergeben. Beachten Sie jedoch, dass Sie die Vergleichsfunktion selbst schreiben müssen. Diese Funktion muss zwei Parameter haben, da sie festlegt, welches ihrer beiden Argumente zuerst in der sortierten Liste erscheinen soll. Um das Verständnis und das Schreiben einer solchen Funktion zu erleichtern, gibt es mehrere Regeln, nach denen die Reihenfolge der Elemente bestimmt wird:

• Muss das erste Argument vor dem zweiten stehen, gibt die Vergleichsfunktion eine negative Zahl zurück (wenn a
• Wenn das erste Argument dem zweiten folgen muss, dann gibt die Vergleichsfunktion eine positive Zahl zurück (wenn a> b)
• Wenn die beiden Werte gleich sind (d.h. die Reihenfolge ist nicht wichtig), gibt die Vergleichsfunktion 0 zurück (wenn a == b)

Zum Vergleich verwendet die Funktion die Elemente des Arrays als Argumente:

Funktion foo (a, b) (// Definiere eine Testfunktion if (a b) return 1; return 0; // if a == b) var a =; a.sortieren (foo); // nur der Funktionsname wird als Argument übergeben document.write (a.join (",")); // dasselbe schreiben kürzer var a =; a.sort (Funktion (a, b) (// anonyme Funktion verwenden return a - b; // Funktion gibt 0) zurück); document.write (a); // 1,2,5,10 Probieren Sie es aus "

Der erste Eintrag im Beispiel ist so geschrieben, dass die Funktionsweise leichter verständlich ist. Beachten Sie, wie praktisch es ist, im zweiten Snippet eine anonyme Funktion zu verwenden. Es wird nur einmal aufgerufen, sodass es nicht erforderlich ist, ihm einen Namen zu geben.

Hinweis: Wenn das Array undefinierte Elemente enthält, werden sie bis zum Ende des Arrays umgebrochen.

Slice-Methode

Die Methode Array.slice() wird verwendet, um den angegebenen Bereich aus dem Array zu kopieren und ein neues Array mit den kopierten Elementen zurückzugeben. Dadurch wird das ursprüngliche Array nicht geändert.

Methodensyntax:

ArrayName.slice (Beginn, Ende);

Array_name sollte durch den Namen des Arrays ersetzt werden, aus dem Sie einen bestimmten Satz von Elementen für ein neues Array abrufen möchten. Die Methode verwendet zwei Argumente, die den Anfang und das Ende des zurückgegebenen Teils des Arrays definieren. Die Methode kopiert einen Teil des Arrays von Anfang bis Ende, ohne Ende. Wenn nur ein Argument angegeben wird, enthält das zurückgegebene Array alle Elemente von der angegebenen Position bis zum Ende des Arrays. Sie können negative Indizes verwenden - sie werden ab dem Ende des Arrays gezählt.

Var arr =; Arr.-Scheibe (0,3); // Gibt arr.slice (3) zurück; // Gibt arr.slice zurück (1, -1); // Gibt arr.slice zurück (-3, -2); // Kehrt zurück

Spleißmethode

Die Methode Array.splice() ist eine generische Methode zum Arbeiten mit Arrays. Es modifiziert das Array an Ort und Stelle, anstatt ein neues geändertes Array zurückzugeben, wie es die Methoden Slice() und concat() tun. Die Splice-Methode kann Elemente aus einem Array entfernen, neue Elemente einfügen, Elemente ersetzen - einzeln und gleichzeitig. Es gibt ein Array der entfernten Elemente zurück, wenn keines der Elemente entfernt wurde, wird ein leeres Array zurückgegeben.

Methodensyntax:

ArrayName.splice (Index, Menge, elem1, ..., elemN);

Das erste Argument gibt den Index im Array an, an dem mit dem Einfügen oder Entfernen von Elementen begonnen werden soll. Das zweite Argument legt die Anzahl der Elemente fest, die aus dem Array entfernt werden sollen, beginnend mit dem im ersten Argument angegebenen Index. Wenn das zweite Argument 0 ist, werden die Elemente nicht entfernt. Wenn das zweite Argument weggelassen wird, werden alle Array-Elemente vom angegebenen Index bis zum Ende des Arrays entfernt. Bei Verwendung einer negativen Positionsnummer werden die Elemente ab dem Ende des Arrays gezählt.

Var Früchte = ["Orangen", "Äpfel", "Birnen", "Trauben"]; var gelöscht = früchte.spleiß (2,2); // gibt ["pears", "trauben"] zurück document.write (gelöscht); var arr =; arr.spleiß (4); // Kehrt zurück; das Array ist geworden: arr.splice (1,2); // Kehrt zurück; das Array wurde: arr.splice (1,1); // Kehrt zurück; das Array ist geworden: Try"

Die ersten beiden Argumente der Methode splice() geben die zu entfernenden Array-Elemente an. Auf diese beiden Argumente können beliebig viele weitere Argumente folgen, die die in das Array einzufügenden Elemente angeben, beginnend an der Position, die durch das erste Argument angegeben wird.

Var Früchte = ["Orangen", "Äpfel"]; Früchte.Splice (2,0, "Wassermelonen"); // gibt document.write (Früchte) zurück; // jetzt ["Orangen", "Äpfel", "Wassermelonen"] var arr =; arr.spleiß (2,0, "a", "b"); // Kehrt zurück; wurde arr.spleiß (2,2,); // Gibt ["a", "b"] zurück; wurde, 3,4,5] Versuchen Sie "

Es sollte beachtet werden, dass im Gegensatz zu concat() die Methode splice() die als Argument übergebenen Arrays nicht in separate Elemente aufteilt. Das heißt, wenn ein Array zum Einfügen an die Methode übergeben wird, fügt sie das Array selbst ein, nicht die Elemente dieses Arrays.

ToString-Methode

Die Methode toString() wandelt die Elemente eines Arrays in einen String um, wobei ein Komma als Trennzeichen verwendet wird.

Var arr = ["Milch", "Brot", "Kekse"]; var food = arr.toString (); document.write (Nahrung); // Milch, Brot, Kekse Probieren Sie es aus "

Beachten Sie, dass die Methode dieselbe Zeichenfolge wie join() zurückgibt, wenn sie ohne Argumente aufgerufen wird.

indexOf und lastIndexOf

Die Methode indexOf gibt den Index eines Elements zurück, dessen Wert gleich dem als Argument an die Methode übergebenen Wert ist.

Die Syntax für die Methoden indexOf () und lastIndexOf () lautet:

Array_name.indexOf (lookup_item, index) array_name.lastIndexOf (lookup_item, index)

Das erste Argument der Methode gibt den Wert des Elements an, dessen Index gesucht werden soll, das zweite Argument (optional) gibt den Index an, ab dem die Suche gestartet werden soll. Bei mehreren identischen Vorkommen wird der kleinste (erste) Index ausgewählt. Wird ein Element mit dem gewünschten Wert nicht gefunden, gibt die Methode -1 zurück. Innerhalb der Methode wird strenger Vergleich (===) für die Suche verwendet.

Vara =; a.indexOf (3); // gibt 2 zurück a.indexOf (3,4); // gibt 6 zurück a.indexOf (35); // gibt -1 zurück: Es gibt kein Element mit diesem Wert a.indexOf (2); // eins

Die Methode lastIndexOf() gibt auch den Index eines Elements zurück, dessen Wert gleich dem als Argument an die Methode übergebenen Wert ist. Der einzige Unterschied besteht darin, dass die Methode lastIndexOf() den höchsten (letzten) Index auswählt.

Vara =; a.lastIndexOf (3); // gibt 7 zurück a.lastIndexOf (35); // gibt -1 zurück: Es gibt kein Element mit diesem Wert a.lastIndexOf (2); // 6

Iteratormethoden

Die unten beschriebenen Methoden sind Iteratoren. Insgesamt moderne Browser Für die Arbeit mit Arrays gibt es Methoden, die die Elemente durchlaufen und verschiedene Aktionen mit ihnen ausführen. Dies sind die Methoden forEach (), map (), filter (), every (), some, Reduce () und ReduceRight ().

Sie durchlaufen die Array-Elemente von 0 bis Länge - 1 und übergeben es, falls das Element existiert, an die Callback-Handler-Funktion.

für jede

Methodensyntax:

ArrayName.forEach (Rückruf, thisArg)

Das erste Argument ist eine Callback-Funktion, die die Methode forEach() für jedes Element des Arrays aufruft. Sie müssen die Implementierung der aufgerufenen Handlerfunktion selbst schreiben. Die aufgerufene Funktion muss drei Parameter haben: Der erste Parameter nimmt den Wert des Array-Elements als Argument, der zweite den Index des Elements und der dritte das Array selbst. Wenn Sie jedoch nur die Werte der Array-Elemente verwenden möchten, können Sie eine Funktion mit nur einem Parameter schreiben. Das zweite Argument, thisArg (optional), wird als this-Wert übergeben.

Var arr =; Funktion foo (Wert) (var Summe = Wert * this; Rückgabe document.write (Summe + "
");) arr.forEach (foo, 5); // das zweite Argument wird als Wert übergeben // dieses Beispiel mit drei Parametern var a =; a.forEach (function (el, idx, a) (document. schreiben ( "a [" + idx + "] =" + el + "in [" + a + "]
");)); Versuchen"

Filter

Methodensyntax:

ArrayName.filter (Rückruf, thisObject)

Die Methode filter() erstellt und gibt ein neues Array zurück, das nur die Array-Elemente enthält, für die ein Aufruf der Callback-Funktion true zurückgibt.

Funktion isBig (element, index, array) (// gibt Zahlen größer oder gleich 10 zurück return (element> = 10); // wenn der Elementwert größer oder gleich 10 ist, gibt der Ausdruck true zurück) var gefiltert = .filter (isBig) ; // gefiltert

Karte

Die Methode map() erstellt und gibt ein neues Array zurück, das aus den Ergebnissen des Aufrufs der Callback-Funktion (item, idx, ar) für jedes Element im Array besteht.

Vara =; var b = a.map (function (item, idx, arr) (return item * item;)); // b =

jeder und einige

Jede ()-Methode gibt true zurück, wenn die angegebene Funktion, mit der sie getestet wurden, für alle Elemente des Arrays true zurückgibt.

Die Methode some() gibt true zurück, wenn während der Validierung in der angegebenen Funktion ein oder mehrere Elemente true zurückgeben.

Vara =; a.every (function (x) (return x 10;)) // true: eine Zahl> 10

reduzieren und reduzierenRecht

Methodensyntax:

ArrayName.reduce (Rückruf, initialValue) ArrayName.reduceRight (Rückruf, initialValue)

Die Methode Reduce() wendet die angegebene Funktion (Callback) gleichzeitig auf zwei Werte im Array an und durchläuft die Elemente von links nach rechts, während das Zwischenergebnis beibehalten wird.

Argumente der Callback-Funktion: (vorherigerWert, aktuellesItem, Index, Array)

• previousValue - das Rückgabeergebnis der Callback-Funktion (auch bekannt als Zwischenergebnis)
• currentItem - das aktuelle Element im Array (Elemente werden der Reihe nach von links nach rechts iteriert)
• index - der Index des aktuellen Elements
• Array - das Array, das verarbeitet wird

initialValue Das Objekt, das als erstes Argument für den ersten Aufruf der Callback-Funktion verwendet wird. Einfach ausgedrückt ist der Wert von previousValue beim ersten Aufruf gleich initialValue. Wenn kein initialValue vorhanden ist, entspricht es dem ersten Element des Arrays und die Iteration beginnt mit dem zweiten:

Vara =; Funktion foo (prevNum, curNum) (sum = prevNum + curNum; alert (sum); Summe zurückgeben;) var result = a.reduce (foo, 0); document.write (Ergebnis); Versuchen "

Sehen wir uns an, wie dieses Beispiel funktioniert. Die ersten Argumente für foo sind:

• prevNum = 0 (da initialValue 0 ist)
• curNum = 1 (aktuelles Element ist das 1. Element des Arrays)

Die Zahl 0 wird zu 1 addiert. Dieses Ergebnis (Summe: 1) wird beim nächsten Ausführen der Funktion als prevNum übergeben. Und so weiter, bis es zum letzten Element kommt. Das zurückgegebene Ergebnis - die Summe aus dem letzten Lauf ist 15 (1 + 2 + 3 + 4 + 5).

Die Methode ReduceRight funktioniert ähnlich wie die Methode Reduce, durchläuft das Array jedoch von rechts nach links:

Var a = ["h", "o", "m", "e"]; Funktionsleiste (prevStr, curItem) (Rückgabe prevStr + curItem;) document.write (a.reduceRight (bar)); // emoh

• Übersetzung

• I. Iteration über reale Arrays
  1. Für jede Methode und verwandte Methoden
  2. Für Schleife
  3. Richtige Verwendung für ... in Schleife
  4. For ... of loop (implizite Verwendung eines Iterators)
  5. Explizite Verwendung eines Iterators
• 1. Verwenden von Methoden zum Iterieren über echte Arrays
  2. Umwandlung in ein echtes Array
  3. Ein Hinweis zu Laufzeitobjekten

I. Iteration über reale Arrays

Im Moment gibt es drei Möglichkeiten, über die Elemente eines echten Arrays zu iterieren:

1. Array.prototype.forEach-Methode;
2. klassische for-Schleife;
3. Eine "wohlgeformte" für ... in Schleife.

Darüber hinaus werden in Kürze mit dem Aufkommen des neuen ECMAScript 6 (ES 6) Standards zwei weitere Möglichkeiten erwartet:

1. for ... of loop (implizite Verwendung eines Iterators);
2. explizite Verwendung eines Iterators.

1. Die forEach-Methode und verwandte Methoden

Wenn Ihr Projekt darauf ausgelegt ist, die Fähigkeiten des ECMAScript 5 (ES5)-Standards zu unterstützen, können Sie eine seiner Innovationen verwenden - die forEach-Methode.

Anwendungsbeispiel:
var a = ["a", "b", "c"]; a.forEach (Funktion (Eintrag) (console.log (Eintrag);));
Im Allgemeinen erfordert die Verwendung von forEach die Verbindung der es5-shim-Emulationsbibliothek für Browser, die diese Methode nicht nativ unterstützen. Dazu gehören IE 8 und höher frühe Versionen, die an einigen Stellen noch verwendet werden.

Der Vorteil von forEach besteht darin, dass keine lokalen Variablen deklariert werden müssen, um den Index und den Wert des aktuellen Array-Elements zu speichern, da diese automatisch als Argumente an die Callback-Funktion übergeben werden.

Wenn Sie sich über die potenziellen Kosten für einen Rückruf für jeden Artikel Sorgen machen, machen Sie sich keine Sorgen und lesen Sie dies.

ForEach wurde entwickelt, um über alle Elemente eines Arrays zu iterieren, aber abgesehen davon bietet ES5 mehrere weitere nützliche Methoden, um alle oder einige der Elemente zu iterieren und einige Aktionen mit ihnen durchzuführen:

• Every - gibt true zurück, wenn der Callback für jedes Element des Arrays einen Wert zurückgibt, der in true umgewandelt wird.
• some - gibt true zurück, wenn der Callback für mindestens ein Element des Arrays einen Wert zurückgibt, der in true umgewandelt wird.
• filter - erstellt ein neues Array, das die Elemente des ursprünglichen Arrays enthält, für die der Callback true zurückgibt.
• map - erstellt ein neues Array bestehend aus den vom Callback zurückgegebenen Werten.
• Reduce - reduziert ein Array auf einen einzelnen Wert, wobei ein Callback der Reihe nach auf jedes Element des Arrays angewendet wird, beginnend mit dem ersten (kann nützlich sein, um die Summe der Array-Elemente und andere endgültige Funktionen zu berechnen).
• ReduceRight - Funktioniert ähnlich wie Reduce, durchläuft jedoch die Elemente in umgekehrter Reihenfolge.

2. Die for-Schleife

Gut alt für Regeln:

Var a = ["a", "b", "c"]; var-Index; für (Index = 0; Index< a.length; ++index) { console.log(a); }
Wenn die Länge des Arrays während der gesamten Schleife unverändert bleibt und die Schleife selbst zu einem performancekritischen Codestück gehört (was unwahrscheinlich ist), können Sie die "optimalere" Version von for verwenden, um die Länge der zu speichern Array:

Var a = ["a", "b", "c"]; var-Index, len; für (index = 0, len = a.length; index< len; ++index) { console.log(a); }
Theoretisch sollte dieser Code etwas schneller laufen als der vorherige.

Wenn die Iterationsreihenfolge nicht wichtig ist, können Sie in Bezug auf die Optimierung noch weiter gehen und die Variable zum Speichern der Länge des Arrays entfernen, indem Sie die Iterationsreihenfolge in das Gegenteil ändern:

Var a = ["a", "b", "c"]; var-Index; for (index = a.length - 1; index> = 0; --index) (console.log (a);)
In modernen JavaScript-Engines bedeuten diese optimierten Spiele jedoch normalerweise nichts.

3. Korrekte Verwendung der for ... in-Schleife

Wenn Ihnen empfohlen wird, eine for ... in -Schleife zu verwenden, denken Sie daran, dass das Iterieren über Arrays nicht das ist, wofür es gedacht ist. Entgegen dem weit verbreiteten Missverständnis iteriert die for ... in-Schleife nicht über die Array-Indizes, sondern über die aufgezählten Eigenschaften des Objekts.

In einigen Fällen, wie z. B. beim Iterieren über spärliche Arrays, kann for ... in jedoch nützlich sein, vorausgesetzt, Sie treffen einige Vorsichtsmaßnahmen, wie im folgenden Beispiel gezeigt:

// a ist ein Array mit geringer Dichte var a =; a = "a"; a = "b"; a = "c"; for (var key in a) (if (a.hasOwnProperty (key) && /^0$|^\d*$/.test(key) && key<= 4294967294) { console.log(a); } }
In diesem Beispiel werden bei jeder Iteration der Schleife zwei Prüfungen durchgeführt:

1. dass das Array eine eigene Eigenschaft namens key hat (nicht von seinem Prototyp geerbt).
2. dieser Schlüssel ist eine Zeichenfolge, die die dezimale Notation einer ganzen Zahl enthält, deren Wert kleiner als 4294967294 ist. Woher kommt die letzte Zahl? Aus der Definition eines Array-Index in ES5, was bedeutet, dass der größte Index, den ein Element in einem Array haben kann, (2 ^ 32 - 2) = 4294967294 ist.

Natürlich nehmen solche Prüfungen beim Ausführen der Schleife zusätzliche Zeit in Anspruch. Bei einem spärlichen Array ist diese Methode jedoch effizienter als eine for-Schleife, da in diesem Fall nur die Elemente durchlaufen werden, die explizit im Array definiert sind. Im obigen Beispiel werden also nur 3 Iterationen durchgeführt (für die Indizes 0, 10 und 10000) - gegenüber 10001 in der for-Schleife.

Um nicht jedes Mal, wenn Sie ein Array durchlaufen müssen, einen so umständlichen Prüfcode zu schreiben, können Sie ihn als separate Funktion entwerfen:

Funktion arrayHasOwnIndex (array, key) (return array.hasOwnProperty (key) && /^0$|^\d*$/.test(key) && key<= 4294967294; }
Dann wird der Schleifenkörper aus dem Beispiel deutlich reduziert:

For (key in a) (if (arrayHasOwnIndex (a, key)) (console.log (a);))
Der obige Prüfcode ist universell und für alle Fälle geeignet. Stattdessen können Sie eine kürzere Version verwenden, die zwar formal nicht ganz korrekt, aber dennoch für die meisten Fälle geeignet ist:

For (key in a) (if (a.hasOwnProperty (key) && String (parseInt (key, 10)) === key) (console.log (a);))

4. Die for ... of-Schleife (implizite Verwendung eines Iterators)

ES6, noch im Entwurfsstatus, sollte Iteratoren in JavaScript einführen.

Ein Iterator ist ein objektimplementiertes Protokoll, das einen Standardweg definiert, um eine Folge von Werten (endlich oder unendlich) zu erhalten.
Ein Iterator ist ein Objekt, in dem die next()-Methode definiert ist – eine Funktion ohne Argumente, die ein Objekt mit zwei Eigenschaften zurückgibt:

1. done (boolean) - true, wenn der Iterator das Ende der zu wiederholenden Sequenz erreicht hat. Ansonsten falsch.
2. value - definiert den vom Iterator zurückgegebenen Wert. Kann undefiniert (abwesend) sein, wenn die done-Eigenschaft wahr ist.

Viele eingebaute Objekte, inkl. Reale Arrays haben Standard-Iteratoren. Der einfachste Weg, einen Iterator für reale Arrays zu verwenden, besteht darin, das new for ... of-Konstrukt zu verwenden.

Ein Beispiel für die Verwendung für ... von:

Var-Wert; var a = ["a", "b", "c"]; for (val of a) (console.log (val);)
Im obigen Beispiel ruft die for ... of-Schleife implizit den Iterator des Array-Objekts auf, um jeden Wert im Array zu erhalten.

5. Explizite Verwendung eines Iterators

Iteratoren können auch explizit verwendet werden, jedoch wird der Code in diesem Fall viel komplizierter als die for ... of-Schleife. Es sieht aus wie das:

Var a = ["a", "b", "c"]; var it = a.Einträge (); var-Eintrag; while (! (entry = it.next ()). done) (console.log (entry.value);)
In diesem Beispiel gibt die Methode Array.prototype.entries einen Iterator zurück, der verwendet wird, um die Werte des Arrays anzuzeigen. Bei jeder Iteration enthält entry.value ein Array der Form [Schlüssel, Wert].

II. Iterieren über arrayähnliche Objekte

Neben echten Arrays enthält JavaScript auch Array-ähnliche Objekte ... Mit realen Arrays haben sie gemeinsam, dass sie eine Längeneigenschaft und Eigenschaften mit Namen in Form von Zahlen haben, die den Elementen des Arrays entsprechen. Beispiele sind das DOM der NodeList-Auflistung und das Argumente-Pseudo-Array, das in jeder Funktion/Methode verfügbar ist.

1. Verwenden von Methoden zum Iterieren über reelle Arrays

Zumindest die meisten, wenn nicht alle Methoden zum Iterieren über reale Arrays können verwendet werden, um über arrayähnliche Objekte zu iterieren.

Die for und for ... in-Konstrukte können auf Array-ähnliche Objekte genauso angewendet werden wie auf echte Arrays.

ForEach und andere Array.prototype-Methoden gelten auch für Array-ähnliche Objekte. Dazu müssen Sie Function.call oder Function.apply aufrufen.

Wenn Sie beispielsweise forEach auf die childNodes-Eigenschaft eines Node-Objekts anwenden möchten, können Sie dies wie folgt tun:

Array.prototype.forEach.call (node.childNodes, function (child) (// etwas mit dem untergeordneten Objekt machen));
Zur einfacheren Wiederverwendung dieser Technik können Sie einen Verweis auf die Methode Array.prototype.forEach in einer separaten Variablen deklarieren und als Kurzform verwenden:

// (Dies setzt voraus, dass sich der gesamte untenstehende Code im selben Bereich befindet) var forEach = Array.prototype.forEach; // ... forEach.call (node.childNodes, function (child) (// etwas mit dem Kindobjekt machen));
Wenn ein Array-ähnliches Objekt einen Iterator hat, dann kann dieser explizit oder implizit verwendet werden, um das Objekt wie bei echten Arrays zu durchlaufen.

2. In ein echtes Array umwandeln

Es gibt auch eine andere, sehr einfache Möglichkeit, über ein Array-ähnliches Objekt zu iterieren: Konvertieren Sie es in ein echtes Array und verwenden Sie eine der oben genannten Methoden, um über echte Arrays zu iterieren. Zur Konvertierung können Sie die generische Methode Array.prototype.slice verwenden, die auf jedes Array-ähnliche Objekt angewendet werden kann. Dies geschieht ganz einfach, wie im folgenden Beispiel gezeigt:

Var trueArray = Array.prototype.slice.call (arrayLikeObject, 0);
Wenn Sie beispielsweise eine NodeList-Sammlung in ein echtes Array konvertieren möchten, benötigen Sie folgenden Code:

Var divs = Array.prototype.slice.call (document.querySelectorAll ("div"), 0);
Aktualisieren: Wie in den Kommentaren vermerkt

Arrays sind eine der am häufigsten verwendeten Variablentypen, mit denen Sie viele aufeinanderfolgende Werte an „einem Ort“ speichern können. Wenn es um JavaScript geht, gibt es jedoch einiges zu verwerfen.

In diesem Artikel werfen wir einen Blick auf drei wenig bekannte Techniken, die Sie beim Arbeiten mit Arrays anwenden können.

1. Hinzufügen von benutzerdefinierten Eigenschaften zu Arrays

Wenn Sie die Suche verwenden, um die Definition eines Arrays in JavaScript zu finden, behaupten die meisten Quellen, dass ein bestimmter Typ von Variablenwert als Objekt dargestellt wird.

Im Allgemeinen sind viele Dinge, denen wir in JavaScript begegnen, Objekte. Es ist fair anzumerken, dass die Sprache auch „primitive“ Datentypen enthält, deren Werte jedoch irgendwie in Eigenschaften innerhalb von Objekten verwendet werden.

2. Zugriff auf Array-Elemente innerhalb einer Schleife

Da Array-Indizes nur positive Werte annehmen können, beginnt der Ursprung bei Null. Anschließend können wir diesen Index verwenden, um bei dieser Iteration der Schleife auf das Array-Element zuzugreifen.

ECMAScript6 führte eine Möglichkeit ein, ein Array zu durchlaufen, ohne Indizes zu verwenden, und eine neue for... of-Schleife.

Die for ... of-Schleife wurde entwickelt, um über die Elemente eines Arrays zu iterieren, ohne den Index des Elements zu beeinflussen.

Var ary = ["Orange", "Apfel", "Litschi"]; for (let item of ary) (console.log (item);) // "orange", "apple", "lychee" Zum Vergleich: Anzeige der Indizes von Items in einer for-Schleife. var ary = ["Orange", "Apfel", "Litschi"]; für (var item = 0; item< ary.length; item++){ console.log(item); } // 0, 1, 2

3. Die Anzahl der Elemente ist nicht die Dimension des Arrays

Wenn wir über die Dimension eines Arrays sprechen, denken wir normalerweise, dass wir die Anzahl der darin gespeicherten Elemente meinen. Tatsächlich ist dies nicht ganz richtig - die Längeneigenschaft wird in Abhängigkeit vom maximalen Index des Elements berechnet.

Die Längeneigenschaft ist höchst mehrdeutig. Um sich davon zu überzeugen, schauen Sie sich einfach die folgenden Manipulationen an:

Variieren =; ary.Länge = 3; console.log (ary.length); // 3 ary = "abcd"; console.log (ary.length); // 6

Im letzten Beispiel reichte es aus, das Element an die 5. Position zu setzen, wodurch die Länge des Arrays gleich 6 wurde. Wenn Sie glauben, dass Indizes von 0 bis 4 automatisch erstellt werden, werden Sie falsch. Dies kann mit dem Operator in überprüft werden.

Variieren =; ary.Länge = 3; console.log (ary.length); // 3 ary = "abcd"; console.log (ary.length); // 6 console.log (0 in ary); // falsch

In diesem Fall wäre es fair, das Array-Array "sparse" zu nennen.

Wir können auch die Eigenschaft length manipulieren, um die Arrays zu trimmen. Das folgende Beispiel demonstriert den „Verlust“ des Elements bei Index 5, indem der Wert der Eigenschaft length des Arrays ary verringert wird.

Variieren =; ary.Länge = 3; console.log (ary.length); // 3 ary = "abcd"; console.log (ary.length); // 6 ary.länge = 2; console.log (ary.length); // 2 console.log (ary); // nicht definiert