JavaScript – Arrays. Array-Elemente in umgekehrter Reihenfolge neu anordnen – umgekehrt
21.06.2017 um 12:17 Uhr
Um die Größe eines Arrays von Objekten in JavaScript zu berechnen, verwenden Sie die Längeneigenschaft des Arrays.
Var arr = ["erster", "zweiter"]; console.log(arr.length); // 2
Arrays in Javascript können Lücken in ihren Indizes aufweisen. Zum Beispiel
Var arr = ; arr = „zuerst“; arr = "zweite";
Die Längeneigenschaft gibt den maximalen Array-Index + 1 zurück. D.h. im gegebenen Beispiel ist die Länge = 5.
Berechnen der Anzahl der Elemente in einem Array in Javascript
Array.prototype.count = function()( var result = 0; for(var i = 0; i< this.length; i++) if (this[i] != undefined) result++; return result; }
Anwendungsbeispiel
Var arr = ; arr = „zuerst“; arr = "zweite"; console.log(arr.count()); //2
Sie können der Längeneigenschaft auch einen Wert zuweisen. Dadurch können Sie die Länge eines vorhandenen Arrays reduzieren.
Var arr = ["erster", "zweiter", "dritter"]; arr.length = 2; Konsolenprotokoll(arr); // ["erste Sekunde"]
Berechnen der Größe eines Arrays in Bytes in Javascript
Arrays sind gewöhnliche Objekte, daher unterscheidet sich die Berechnung der Größe eines Arrays in Bytes nicht von der Berechnung der Größe jedes anderen Objekts. Leider bietet Javascript keine API zur Berechnung der Größe, sodass Sie diese selbst berechnen müssen. Dies geschieht wie folgt: Wir umgehen alle Eigenschaften des Objekts. Wenn die Eigenschaft von einem primitiven Typ ist, addieren wir die Größe einer Instanz dieses Typs zum Gesamtergebnis. Wenn die Eigenschaft ein Objekt enthält, berechnen wir es rekursiv Größe.
Funktion sizeOf(obj) ( var bytes = 0; if(obj !== null && obj !== undefiniert) ( switch(typeof obj) ( case „number“: bytes += 8; break; case „string“: bytes += obj.length * 2; break; case „boolean“: bytes += 4; break; case „object“: for(var key in obj) ( bytes += sizeOf(obj); ) break; ) ) Bytes zurückgeben ; );
Die Methode ist nicht genau und hat viele Probleme – zum Beispiel ist es wahrscheinlich, dass sie in eine Endlosschleife gerät.
Letzte Aktualisierung: 26.03.2018
Das Array-Objekt stellt ein Array dar und stellt eine Reihe von Eigenschaften und Methoden bereit, mit denen wir das Array manipulieren können.
Array-Initialisierung
Es ist möglich, mit ein leeres Array zu erstellen eckige Klammern oder der Array-Konstruktor:
varusers = new Array(); var people = ; Konsolenprotokoll (Benutzer); // Array console.log(people); // Array
Sie können ein Array sofort mit einer bestimmten Anzahl von Elementen initialisieren:
Varuser = new Array("Tom", "Bill", "Alice"); var people = ["Sam", "John", "Kate"]; Konsolenprotokoll (Benutzer); // ["Tom", "Bill", "Alice"] console.log(people); // [„Sam“, „John“, „Kate“]
Sie können ein Array definieren und nach und nach neue Elemente darin definieren:
varusers = new Array(); Benutzer = "Tom"; Benutzer = „kate“; Konsolenprotokoll (Benutzer); // „Tom“ console.log(users); // nicht definiert
Es spielt keine Rolle, dass das Array standardmäßig mit der Länge Null erstellt wird. Mit Hilfe von Indizes können wir einen bestimmten Index in einem Array durch das eine oder andere Element ersetzen.
Länge
Um die Länge eines Arrays herauszufinden, verwenden Sie die Längeneigenschaft:
var Fruit = new Array(); Frucht = „Äpfel“; Frucht = „Birnen“; Frucht = „Pflaumen“; document.write("Im Array Fruit " + Fruit.length + " Element:
"); for(var i=0; i< fruit.length; i++)
document.write(fruit[i] + "
");
Tatsächlich entspricht die Länge des Arrays dem Index des letzten Elements plus eins. Zum Beispiel:
varusers = new Array(); // es gibt 0 Elemente im Array users = "Tom"; Benutzer = „kate“; Benutzer = "sam"; for(var i=0; i Browserausgabe: Tom Kate 2020 Andere Sam Obwohl wir keine Elemente für die Indizes 2 und 3 hinzugefügt haben, beträgt die Länge des Arrays in diesem Fall die Zahl 5. Die Elemente an den Indizes 2 und 3 haben lediglich den Wert undefined . Das Kopieren eines Arrays kann flach oder flach (flache Kopie) und tief (tiefe Kopie) sein. Für flaches Kopieren reicht es aus, den Wert einer anderen Variablen, die das Array speichert, einer Variablen zuzuweisen: varuser = ["Tom", "Sam", "Bill"]; Konsolenprotokoll (Benutzer); // ["Tom", "Sam", "Bill"] var people = Benutzer; // flache Kopie people = "Mike"; // das zweite Element ändern console.log(users); // [„Tom“, „Mike“, „Bill“] In diesem Fall zeigt die Variable „people“ nach dem Kopieren auf dasselbe Array wie die Variable „users“. Wenn Sie also die Elemente in „people“ ändern, ändern sich auch die Elemente in „users“, da es sich tatsächlich um dasselbe Array handelt. Dieses Verhalten ist nicht immer wünschenswert. Beispielsweise möchten wir, dass die Variablen nach dem Kopieren auf separate Arrays verweisen. Und in diesem Fall können Sie Deep Copying mit der Methode „slice()“ verwenden: varuser = ["Tom", "Sam", "Bill"]; Konsolenprotokoll (Benutzer); // ["Tom", "Sam", "Bill"] var people = users.slice(); // Deep Copy people = "Mike"; // das zweite Element ändern console.log(users); // ["Tom", "Sam", "Bill"] console.log(people); // [„Tom“, „Mike“, „Bill“] In diesem Fall verweisen die Variablen nach dem Kopieren auf verschiedene Arrays und wir können sie getrennt voneinander ändern. Außerdem können Sie mit der Methode „slice()“ einen Teil eines Arrays kopieren: Varuser = ["Tom", "Sam", "Bill", "Alice", "Kate"]; var people = users.slice(1, 4); Konsolenprotokoll (Personen); // [„Sam“, „Bill“, „Alice“] Der Methode „slice()“ wird ein Start- und ein Endindex übergeben, mit denen Werte aus dem Array abgerufen werden. Das heißt, in diesem Fall erfolgt die Auswahl im neuen Array von Index 1 bis Index 4, nicht eingeschlossen. Und da die Array-Indizierung bei Null beginnt, enthält das neue Array das zweite, dritte und vierte Element. Die Methode push() fügt ein Element am Ende eines Arrays hinzu: var Frucht = ; Fruit.push("Äpfel"); Fruit.push("Birnen"); Fruit.push("Pflaumen"); Fruit.push("Cherry","Apricot Die Methode pop() entfernt das letzte Element aus dem Array: Var Fruit = [„Äpfel“, „Birnen“, „Pflaumen“]; var lastFruit = Fruit.pop(); // letztes Element aus dem Array abrufen document.write(lastFruit + " Browserausgabe: Die Pflaumen-Fruchtreihe besteht aus 2 Elementen: Äpfel, Birnen Die Methode „shift()“ ruft das erste Element aus dem Array ab und entfernt es: Var Fruit = [„Äpfel“, „Birnen“, „Pflaumen“]; var firstFruit = Fruit.shift(); document.write(firstFruit + " Browserausgabe: Das Obstsortiment „Äpfel“ besteht aus 2 Elementen: Birnen, Pflaumen Die Methode unshift() fügt am Anfang des Arrays ein neues Element hinzu: Var Fruit = [„Äpfel“, „Birnen“, „Pflaumen“]; Fruit.unshift("Aprikosen"); document.write(fruit); Browserausgabe: Aprikosen, Äpfel, Birnen, Pflaumen Die Methode splice() entfernt Elemente aus einem bestimmten Index. Zum Beispiel Elemente aus dem dritten Index entfernen: Varuser = ["Tom", "Sam", "Bill", "Alice", "Kate"]; var gelöscht = users.splice(3); Konsolenprotokoll (gelöscht); // [ „Alice“, „Kate“ ] console.log(users); // [ „Tom“, „Sam“, „Bill“ ] Die Slice-Methode gibt die entfernten Elemente zurück. In diesem Fall erfolgt die Löschung am Anfang des Arrays. Wenn Sie einen negativen Index übergeben, erfolgt die Entfernung am Ende des Arrays. Entfernen wir zum Beispiel das letzte Element: Varuser = ["Tom", "Sam", "Bill", "Alice", "Kate"]; var gelöscht = users.splice(-1); Konsolenprotokoll (gelöscht); // [ „Kate“ ] console.log(users); // [ „Tom“, „Sam“, „Bill“, „Alice“ ] Eine zusätzliche Version der Methode ermöglicht es Ihnen, den zu löschenden Endindex anzugeben. Entfernen wir zum Beispiel den ersten bis dritten Index: Varuser = ["Tom", "Sam", "Bill", "Alice", "Kate"]; var gelöscht = users.splice(1,3); Konsolenprotokoll (gelöscht); // [ „Sam“, „Bill“, „Alice“ ] console.log(users); // [ „Tom“, „Kate“ ] Eine andere Version der Spleißmethode ermöglicht es Ihnen, neue Elemente anstelle der entfernten Elemente einzufügen: Varuser = ["Tom", "Sam", "Bill", "Alice", "Kate"]; var gelöscht = users.splice(1,3, „Ann“, „Bob“); Konsolenprotokoll (gelöscht); // [ „Sam“, „Bill“, „Alice“ ] console.log(users); // [ „Tom“, „Ann“, „Bob“, „Kate“ ] In diesem Fall entfernen wir drei Elemente vom 1. bis 3. Index und fügen stattdessen zwei Elemente ein. Die Methode concat() wird zum Verketten von Arrays verwendet: Var Fruit = [„Äpfel“, „Birnen“, „Pflaumen“]; var Gemüse = ["Tomaten", "Gurken", "Kartoffeln"]; var products = Fruit.concat(vegetables); for(var i=0; i< products.length; i++)
document.write(products[i] + " In diesem Fall ist es nicht notwendig, nur Arrays desselben Typs zu kombinieren. Sie können auch verschiedene Typen haben: Var Fruit = [„Äpfel“, „Birnen“, „Pflaumen“]; var Preise = ; var products = Fruit.concat(prices); Die Methode join() verkettet alle Array-Elemente zu einem String: Var Fruit = [„Äpfel“, „Birnen“, „Pflaumen“, „Aprikosen“, „Pfirsiche“]; var FruitString = Fruit.join(", "); document.write(fruitString); Der Methode join() wird ein Trennzeichen zwischen Array-Elementen übergeben. Als Trennzeichen werden in diesem Fall ein Komma und ein Leerzeichen („,“) verwendet. Die Methode sort() sortiert ein Array in aufsteigender Reihenfolge: Var Fruit = [„Äpfel“, „Birnen“, „Pflaumen“, „Aprikosen“, „Pfirsiche“]; Fruchtsortierung(); for(var i=0; i< fruit.length; i++)
document.write(fruit[i] + " Ausgabe im Browser: Aprikosen, Birnen, Pfirsiche, Pflaumen, Äpfel Die Methode reverse() dreht ein Array rückwärts: Var Fruit = [„Äpfel“, „Birnen“, „Pflaumen“, „Aprikosen“, „Pfirsiche“]; Fruit.reverse(); for(var i=0; i< fruit.length; i++)
document.write(fruit[i] + " Ausgabe im Browser: Pfirsiche Aprikosen Pflaumen Birnen Äpfel In Kombination mit der Methode sort() können Sie ein Array in absteigender Reihenfolge sortieren: Var Fruit = [„Äpfel“, „Birnen“, „Pflaumen“, „Aprikosen“, „Pfirsiche“]; Fruit.sort().reverse(); for(var i=0; i< fruit.length; i++)
document.write(fruit[i] + " Ausgabe im Browser: Äpfel, Pflaumen, Pfirsiche, Birnen, Aprikosen Die Methoden indexOf() und lastIndexOf() geben den Index des ersten und letzten Vorkommens eines Elements in einem Array zurück. Zum Beispiel: Var Fruit = [„Äpfel“, „Birnen“, „Pflaumen“, „Äpfel“, „Birnen“]; var firstIndex = Fruit.indexOf("apples"); var lastIndex = obst.lastIndexOf("äpfel"); var otherIndex = Fruit.indexOf("cherries"); document.write(firstIndex); // 0 document.write(lastIndex); // 3 document.write(otherIndex); // -1 firstIndex ist 0, da das erste Vorkommen der Zeichenfolge „apples“ im Array bei Index 0 und das letzte bei Index 3 liegt. Wenn sich das Element nicht im Array befindet, geben die Methoden indexOf() und lastIndexOf() -1 zurück. Die Methode every() prüft, ob alle Elemente eine bestimmte Bedingung erfüllen: Var-Zahlen = [ 1, -12, 8, -4, 25, 42 ]; Funktionsbedingung(Wert, Index, Array) ( var result = false; if (value > 0) ( result = true; ) return result; ); var übergeben = zahlen.every(condition); document.write(bestanden); // FALSCH Der Methode every() wird eine Funktion übergeben, die die Bedingung als Parameter darstellt. Diese Funktion benötigt drei Parameter: Funktionsbedingung (Wert, Index, Array) ( ) Der Wertparameter stellt das aktuelle Array-Element dar, das iteriert wird, der Indexparameter stellt den Index dieses Elements dar und der Array-Parameter übergibt einen Verweis auf das Array. In dieser Funktion können wir den übergebenen Wert des Elements anhand einer Bedingung überprüfen. In diesem Beispiel prüfen wir beispielsweise jedes Element des Arrays, um festzustellen, ob es größer als Null ist. Ist er größer, geben wir den Wert true zurück, d. h. das Element entspricht der Bedingung. Wenn weniger, dann wird false zurückgegeben – das Element entspricht nicht der Bedingung. Wenn die Methode „numbers.every(condition)“ aufgerufen wird, durchläuft sie daher alle Elemente des Arrays „Zahlen“ und übergibt sie der Reihe nach an die Funktion „Bedingung“. Wenn diese Funktion für alle Elemente true zurückgibt, gibt every() true zurück. Wenn mindestens ein Element nicht mit der Bedingung übereinstimmt, gibt die Methode every() false zurück. Die Methode some() ähnelt der Methode every(), prüft jedoch, ob mindestens ein Element die Bedingung erfüllt. Und in diesem Fall gibt die Methode some() true zurück. Wenn im Array keine Elemente vorhanden sind, die der Bedingung entsprechen, wird false zurückgegeben: Var-Zahlen = [ 1, -12, 8, -4, 25, 42 ]; Funktionsbedingung(Wert, Index, Array) ( var result = false; if (value === 8) ( result = true; ) return result; ); var übergeben = zahlen.einige(Bedingung); // WAHR Die Methode filter() akzeptiert wie some() und every() eine Bedingungsfunktion. Gleichzeitig wird aber ein Array der Elemente zurückgegeben, die diese Bedingung erfüllen: Var-Zahlen = [ 1, -12, 8, -4, 25, 42 ]; Funktionsbedingung(Wert, Index, Array) ( var result = false; if (value > 0) ( result = true; ) return result; ); var filteredNumbers = zahlen.filter(bedingung); for(var i=0; i< filteredNumbers.length; i++)
document.write(filteredNumbers[i] + " Ausgabe im Browser: 1
8
25
42
Die Methoden forEach() und map() durchlaufen die Elemente und führen bestimmte Operationen an ihnen aus. Um beispielsweise die Quadrate von Zahlen in einem Array zu berechnen, können Sie den folgenden Code verwenden: var-Zahlen = [ 1, 2, 3, 4, 5, 6]; for(var i = 0; i Aber mit der Methode forEach() können Sie diese Konstruktion vereinfachen: var-Zahlen = [ 1, 2, 3, 4, 5, 6]; Funktion quadrat(Wert, Index, Array) ( var result = value * value; document.write("Das Quadrat der Zahl " + value + " ist " + result + " Die Methode forEach() verwendet als Parameter dieselbe Funktion, an die bei der Iteration über die Elemente das aktuelle Element, das iteriert wird, übergeben wird und Operationen daran ausgeführt werden. Die Methode „map()“ ähnelt der Methode „forEach“. Sie benötigt als Parameter auch eine Funktion, die Operationen an den iterierten Elementen des Arrays ausführt. Die Methode „map()“ gibt jedoch ein neues Array mit den Ergebnissen von Operationen an den Elementen des Arrays zurück . Wenden wir beispielsweise die Kartenmethode an, um die Quadrate der Zahlen in einem Array zu berechnen: var-Zahlen = [ 1, 2, 3, 4, 5, 6]; Funktion quadrat(Wert, Index, Array) ( Rückgabeergebnis = Wert * Wert; ); var quadratArray = zahlen.map(quadrat); document.write(squareArray); Die Funktion, die an die Methode „map()“ übergeben wird, ruft das aktuell iterierte Element ab, führt Operationen daran aus und gibt einen Wert zurück. Dieser Wert wird dann an das resultierende SquareArray übergeben Und wie Sie diesem Artikel entnommen haben, kann in einer Variablen nur ein Wert gespeichert werden. Wie viel würden wir versuchen Wir werden nicht mehr als einen Wert in eine Variable schreiben. Nehmen wir an, wir deklarieren eine Variable z und weisen ihr den Wert 8 zu. Und wenn wir irgendwo weiter unten im Code einen anderen Wert setzen, sagen wir 3, dann verschwindet der alte Wert und stattdessen wird ein neuer geschrieben. Und um mehr als einen Wert in eine Variable schreiben zu können, müssen Sie einen solchen Datentyp als Array verwenden. Array ermöglicht es Ihnen, eine unbegrenzte Anzahl von Werten jeglichen Typs gleichzeitig in eine Variable zu schreiben. Bisher wurde in JavaScript ein Array wie folgt deklariert: Var arr = new Array(7, 8, „k“, „v“, 3.2, 4); Die Zeiten haben sich geändert und Jetzt wird das Array auf andere Weise deklariert, abgekürzt. Elemente werden ebenfalls durch Kommas getrennt aufgelistet, jedoch bereits in einfachen eckigen Klammern. Var arr = [ 7, 8, „k“, „v“, 3.2, 4 ]; Jetzt ist die arr-Variable eindimensionales Datenarray, verschiedene Typen. Jedes Element im Array hat seinen eigenen Index. Bitte beachten Sie, dass dies Der Index beginnt bei Null. Es gibt die Position eines Elements in einem Array an. Array-Struktur sieht so aus: Um auf ein Element aus dem Array zu verweisen, müssen Sie den Namen des Arrays schreiben und in eckigen Klammern den Index des Elements angeben, dessen wir abrufen möchten. Lassen Sie uns beispielsweise das Element anzeigen, dessen Index 2 ist, also den Buchstaben „k“. Document.write(" Wir zeigen das Element des Arrays arr an, dessen Index gleich 2 ist: " + arr + "Kopieren eines Arrays. Scheibe()
drücken()
"); document.write(fruit); // Äpfel, Birnen, Pflaumen, Kirschen, AprikosenPop()
"); document.write("Im Array Fruit " + Fruit.length + " Element:
"); for(var i=0; i Schicht()
"); document.write("Im Array Fruit " + Fruit.length + " Element:
"); for(var i=0; i unshift()
Entfernen eines Elements nach Index. spleißen()
concate()
");
verbinden()
Sortieren()
");
umkehren()
");
");
Den Index eines Elements ermitteln
jeden()
manche()
Filter()
");
forEach() und map()
"); ); zahlen.forEach(quadrat);
Was wäre, wenn wir wollen? Alle Elemente eines Arrays anzeigen. Wenn es nur wenige Elemente gibt, können Sie auf jedes einzeln verweisen, wie im Beispiel, also arr, arr, arr.
Wenn das Array jedoch 100 Elemente enthält, funktioniert diese Option nicht. Hier müssen Sie verwenden.
Bevor ich mit der Iteration über ein Array fortfahre, möchte ich Ihnen die Eigenschaft vorstellen Länge. Dies ist eine universelle Eigenschaft, die es ermöglicht Finden Sie die Länge eines Arrays, das ist die Gesamtzahl der Elemente im Array. Es kann auch verwendet werden, um die Länge einer Zeichenfolge herauszufinden.
Lassen Sie uns zum Spaß herausfinden, wie lang das arr-Array ist.
Document.write("
Anzahl der Elemente im Array arr =" + arr.length + "
); // Ergebnis: 6Um nun alle Elemente auf einmal anzuzeigen, Mit einer Schleife über das gesamte Array iterieren.
For(var i = 0; i< arr.length; i++){ document.write("
Array-Element arr, mit Index " + ich + " gleich: " + arr[i] + "
"); }Wir öffnen diese Seite im Browser und sehen folgendes Bild:
Versuchen Sie zum Üben, das Array „arr“ zu durchlaufen und den Rest der while- und do-while-Schleifen zu verwenden.
Es gibt eine weitere einfache und kurze Variante der Aufzählung kleines Array. Es liegt darin, dass jedes Element des Arrays mit der Alert-Methode angezeigt werden kann. Zuerst schreiben wir den Namen des Arrays selbst, oder Sie können sofort eine Liste von Elementen in eckigen Klammern angeben. Dann schreiben wir die Funktion forEach und die Alert-Methode als Parameter ohne Klammern.
Arr.forEach(alert);
Wenn wir nun die Seite im Browser öffnen, sehen wir nacheinander jedes Array-Element.
Füllen eines Arrays mit einer Schleife
In einem bestimmten Array schreiben wir beispielsweise die Ergebnisse der Multiplikationstabelle von 1 bis 10.
Zuerst müssen Sie ein leeres Array deklarieren, das wir füllen. Dann müssen Sie eine Variable deklarieren und ihr sofort den Wert 0 zuweisen. Diese Variable wird als Index für das deklarierte Array verwendet. Und der nächste Schritt besteht darin, das Array selbst mit Hilfe einer Technik wie einem Zyklus im Zyklus zu füllen.
//Deklariere ein leeres Array var new_arr = ; // Variable als Index für Array new_arr var k = 0; for(var i = 1; i
Wenn wir diese Seite in einem Browser öffnen, sehen wir das folgende Ergebnis:
Anfangs ist die Variable i gleich eins. Und dieser wird mit allen Werten der Variablen j multipliziert. Nachdem wir die zweite Schleife 10 Mal durchlaufen haben, kehren wir zur ersten Schleife zurück und erhöhen die Variable i um eins. Jetzt ist i gleich zwei. Wieder gehen wir zur zweiten Schleife und multiplizieren den Wert 2 mit allen Werten der Variablen j (von 1 bis 10). Das Ergebnis ist die zweite Zeile: 2 4 6 8 ... 20. Und das passiert, bis die Variable i gleich 11 wird. Sobald sie diesen Wert annimmt, verlassen wir die Schleife.
Berechnen Sie die Summe aller Elemente eines Arrays
Wir haben ein Array new_arr, das 100 Zahlen speichert (eine ganze Multiplikationstabelle). Berechnen wir nun die Summe all dieser Elemente.
//Erstelle eine Variable für die Summe var summ = 0; for(var i = 0; i< new_arr.length; i++){ summ += new_arr[i]; } document.write("
Die Summe der Elemente des Arrays new_arr ist: „ + summ + „
"); //Ergebnis 3025Das ist alles, worüber ich Ihnen in diesem Artikel erzählen wollte. Jetzt wissen Sie, wie man ein Array erstellt und wie man es füllt und wie man damit arbeitet.
In der Praxis sind Arrays weit verbreitet, da sie in der Programmierung sehr wichtig sind, was Sie auch tun sollten kenne sie gut.
Arrays
Array ist eine geordnete Sammlung von Werten. Die Werte in einem Array werden Elemente genannt, und jedes Element ist durch eine numerische Position im Array gekennzeichnet, die als Index bezeichnet wird. Arrays in JavaScript sind untypisiert: Array-Elemente können jeden Typ haben und verschiedene Elemente desselben Arrays können unterschiedliche Typen haben. Array-Elemente können sogar Objekte oder andere Arrays sein, sodass Sie komplexe Datenstrukturen wie Arrays aus Objekten und Arrays aus Arrays erstellen können.
JavaScript-Array-Indizes basieren auf Nullen und verwenden 32-Bit-Ganzzahlen – das erste Element eines Arrays hat den Index 0. Arrays in JavaScript sind dynamisch: Sie können je nach Bedarf wachsen und schrumpfen; Es ist nicht erforderlich, bei der Erstellung von Arrays feste Größen anzugeben oder Speicher neu zuzuweisen, wenn sich ihre Größe ändert.
Arrays in JavaScript sind eine spezielle Form von Objekten, und Array-Indizes bedeuten kaum mehr als nur Eigenschaftsnamen, die zufällig ganze Zahlen sind.
Arrays erstellen
Der einfachste Weg, ein Array zu erstellen, ist die Verwendung eines Literals, einer einfachen, durch Kommas getrennten Liste von Array-Elementen in eckigen Klammern. Werte in einem Array-Literal müssen keine Konstanten sein – sie können ein beliebiger Ausdruck sein, einschließlich Objektliteralen:
var leer = ; // Leeres Array var zahlen = ; // Ein Array mit fünf numerischen Elementen var misc = [ 1.1, true, "a", ]; // 3 Elemente unterschiedlichen Typs + abschließendes Komma var base = 1024; var-Tabelle = ; // Array mit Variablen var arrObj = [, ]; // 2 Arrays darin, die Objekte enthalten
Die Array-Literal-Syntax ermöglicht ein optionales abschließendes Komma, d. h. Das Literal [,] entspricht einem Array mit zwei Elementen, nicht mit drei.
Eine andere Möglichkeit, ein Array zu erstellen, besteht darin, den Konstruktor aufzurufen array(). Sie können einen Konstruktor auf drei verschiedene Arten aufrufen:
Konstruktor ohne Argumente aufrufen:
Var arr = new Array();
In diesem Fall wird ein leeres Array erstellt, das einem Literal entspricht.
Rufen Sie den Konstruktor mit einem einzelnen numerischen Argument auf, das die Länge des Arrays angibt:
Var arr = neues Array(10);
In diesem Fall wird ein leeres Array der angegebenen Länge erstellt. Diese Form des Aufrufs des Array()-Konstruktors kann verwendet werden, um Speicher für ein Array vorab zuzuweisen, wenn die Anzahl seiner Elemente im Voraus bekannt ist. Beachten Sie, dass dadurch keine Werte im Array gespeichert werden.
Geben Sie im Konstruktoraufruf explizit die Werte der ersten zwei oder mehr Elemente des Arrays oder eines nicht numerischen Elements an:
Var arr = new Array(5, 4, 3, 2, 1, "test");
In diesem Fall werden die Konstruktorargumente zu den Werten der Elemente des neuen Arrays. Die Verwendung von Array-Literalen ist fast immer einfacher als die Verwendung des Array()-Konstruktors auf diese Weise.
Array-Elemente lesen und schreiben
Der Zugriff auf Array-Elemente erfolgt über . Links von den Klammern muss eine Array-Referenz stehen. Innerhalb der Klammern muss ein beliebiger Ausdruck stehen, der einen nicht negativen ganzzahligen Wert zurückgibt. Diese Syntax eignet sich sowohl zum Lesen als auch zum Schreiben des Werts eines Array-Elements. Daher sind alle folgenden JavaScript-Anweisungen gültig:
// Erstelle ein Array mit einem Element var arr = ["world"]; // Element 0 lesen var value = arr; // Wert in Element 1 schreiben arr = 3.14; // Wert in Element 2 schreiben i = 2; arr[i] = 3; // Wert in Element 3 schreiben arr = "hello"; // Elemente 0 und 2 lesen, Wert in Element 3 schreiben arr] = arr;
Ich möchte Sie daran erinnern, dass Arrays eine spezielle Art von Objekten sind. Eckige Klammern, die für den Zugriff auf Array-Elemente verwendet werden, verhalten sich genauso wie eckige Klammern, die für den Zugriff auf Objekteigenschaften verwendet werden. Der JavaScript-Interpreter wandelt die in Klammern gesetzten numerischen Indizes in Zeichenfolgen um – Index 1 wird zur Zeichenfolge „1“ – und verwendet die Zeichenfolgen dann als Eigenschaftsnamen.
Das Konvertieren numerischer Indizes in Zeichenfolgen ist nichts Besonderes. Das Gleiche kann auch mit gewöhnlichen Objekten gemacht werden:
var obj = (); // Ein einfaches Objekt erstellen obj = "one"; // Mit Ganzzahlen indizieren
Die Besonderheit von Arrays besteht darin, dass Arrays bei Verwendung von Eigenschaftsnamen, die nicht negative Ganzzahlen sind, automatisch den Wert der Eigenschaft ermitteln Länge. Das Array arr wurde beispielsweise oben mit einem einzelnen Element erstellt. Anschließend wurden seinen Elementen Werte an den Indizes 1, 2 und 3 zugewiesen. Als Ergebnis dieser Vorgänge änderte sich der Wert der Längeneigenschaft des Arrays in 4.
Sie sollten klar zwischen Array-Indizes und Objekteigenschaftsnamen unterscheiden. Alle Indizes sind Eigenschaftsnamen, aber nur Eigenschaften, deren Namen durch Ganzzahlen dargestellt werden, sind Indizes. Alle Arrays sind Objekte und Sie können ihnen Eigenschaften mit beliebigen Namen hinzufügen. Wenn Sie jedoch Eigenschaften berühren, bei denen es sich um Array-Indizes handelt, reagieren Arrays, indem sie den Wert der Längeneigenschaft nach Bedarf aktualisieren.
Bitte beachten Sie, dass negative und nicht ganzzahlige Zahlen als Array-Indizes verwendet werden dürfen. In diesem Fall werden Zahlen in Zeichenfolgen umgewandelt, die als Eigenschaftsnamen verwendet werden.
Hinzufügen und Entfernen von Array-Elementen
Wir haben bereits gesehen, dass der einfachste Weg, Elemente zu einem Array hinzuzufügen, darin besteht, neuen Indizes Werte zuzuweisen. Sie können die Methode auch verwenden, um ein oder mehrere Elemente am Ende eines Arrays hinzuzufügen. drücken():
Var arr = ; // Erstelle ein leeres Array arr.push("zero"); // Wert zum Ende hinzufügen arr.push("one",2); // Zwei weitere Werte hinzufügen
Sie können ein Element auch am Ende eines Arrays hinzufügen, indem Sie dem arr-Element einen Wert zuweisen. Um ein Element am Anfang eines Arrays einzufügen, können Sie die Methode verwenden unshift(), wodurch die vorhandenen Elemente im Array an höhere Indexpositionen verschoben werden.
Array-Elemente können wie gewöhnliche Objekteigenschaften mit dem Löschoperator gelöscht werden:
Var arr = ; arr löschen; 2 in arr; // false, Array-Index 2 ist nicht definiert arr.length; // 3: Der Löschoperator ändert die Längeneigenschaft des Arrays nicht
Das Entfernen eines Elements ähnelt (jedoch etwas anders) dem Zuweisen von undefiniert zu diesem Element. Beachten Sie, dass die Anwendung des Löschoperators auf ein Element eines Arrays weder den Wert der Längeneigenschaft ändert, noch Elemente mit höheren Indizes nach unten verschiebt, um die Lücke zu füllen, die durch das gelöschte Element entsteht.
Es ist auch möglich, Elemente am Ende eines Arrays zu entfernen, indem Sie einfach der Längeneigenschaft einen neuen Wert zuweisen. Arrays haben eine Methode Pop()(Gegenteil von push()), wodurch die Länge des Arrays um 1 verringert und der Wert des entfernten Elements zurückgegeben wird. Es gibt auch eine Methode Schicht()(Gegenteil der unshift()-Methode), die das Element am Anfang des Arrays entfernt. Im Gegensatz zum Löschoperator verschiebt die Methode „shift()“ alle Elemente nach unten auf eine Position unterhalb ihrer aktuellen Indizes.
Endlich gibt es eine Mehrzweckmethode spleißen(), mit dem Sie Elemente von Arrays einfügen, entfernen und ersetzen können. Es ändert den Wert der Längeneigenschaft und verschiebt Array-Elemente mit niedrigeren oder höheren Indizes nach Bedarf. Wir werden alle diese Methoden etwas später besprechen.
Mehrdimensionale Arrays
JavaScript unterstützt keine „echten“ mehrdimensionalen Arrays, aber es macht es gut, sie mit Arrays von Arrays zu simulieren. Um auf ein Datenelement in einem Array von Arrays zuzugreifen, reicht es aus, den Operator zweimal zu verwenden.
Angenommen, die Variablenmatrix ist ein Array von Zahlenarrays. Jedes Element der Matrix[x] ist ein Array von Zahlen. Um auf eine bestimmte Zahl in einem Array zuzugreifen, können Sie den Ausdruck „matrix[x][y]“ verwenden. Das Folgende ist ein konkretes Beispiel, bei dem ein zweidimensionales Array als Multiplikationstabelle verwendet wird:
// Erstelle ein mehrdimensionales Array var table = new Array(10); // Es gibt 10 Zeilen in der Tabelle for(var i = 0; i
Methoden der Array-Klasse
Der ECMAScript 3-Standard definiert eine Reihe praktischer Funktionen für die Arbeit mit Arrays als Teil von Array.prototype , die als Methoden jedes Arrays verfügbar sind. Diese Methoden werden in den folgenden Unterabschnitten vorgestellt.
join()-Methode
Die Methode Array.join() wandelt alle Array-Elemente in Strings um, verkettet sie und gibt den resultierenden String zurück. Als optionales Argument für die Methode können Sie eine Zeichenfolge übergeben, die zum Trennen von Elementen in der Ergebniszeichenfolge verwendet wird. Wenn keine Trennzeichenfolge angegeben ist, wird ein Komma verwendet. Das folgende Snippet ergibt beispielsweise die Zeichenfolge „1,2,3“:
Var arr = ; arr.join(); // "1,2,3" arr.join("-"); // „1-2-3“
reverse()-Methode
Die Methode Array.reverse() kehrt die Reihenfolge der Elemente in einem Array um und gibt ein neu geordnetes Array zurück. Die Permutation wird direkt am ursprünglichen Array durchgeführt, d. h. Diese Methode erstellt kein neues Array mit neu angeordneten Elementen, sondern ordnet sie in einem bereits vorhandenen Array neu an. Beispielsweise ergibt das folgende Fragment, das die Methoden reverse() und join() verwendet, die Zeichenfolge „3,2,1“:
Var arr = ; arr.reverse().join(); // "3,2,1"
sort()-Methode
Die Methode Array.sort() sortiert die Elemente im ursprünglichen Array und gibt das sortierte Array zurück. Wenn die Methode sort() ohne Argumente aufgerufen wird, erfolgt die Sortierung in alphabetischer Reihenfolge (bei Bedarf werden die Elemente zum Vergleich vorübergehend in Strings umgewandelt). Undefinierte Elemente werden an das Ende des Arrays verschoben.
Um in einer anderen als der alphabetischen Reihenfolge zu sortieren, können Sie eine Vergleichsfunktion als Argument an die Methode sort() übergeben. Diese Funktion legt fest, welches ihrer beiden Argumente in der sortierten Liste an erster Stelle stehen soll. Wenn das erste Argument vor dem zweiten stehen muss, muss die Vergleichsfunktion eine negative Zahl zurückgeben. Wenn das erste Argument dem zweiten im sortierten Array folgen soll, muss die Funktion eine Zahl größer als Null zurückgeben. Und wenn zwei Werte äquivalent sind (d. h. ihre Reihenfolge ist nicht wichtig), sollte die Vergleichsfunktion 0 zurückgeben:
Var arr = ; arr.sort(); // Alphabetische Reihenfolge: 1111, 222, 33, 4 arr.sort(function(a,b) ( // Numerische Reihenfolge: 4, 33, 222, 1111 return a-b; // Gibt den Wert 0 zurück // abhängig von der Sortierreihenfolge a und B)); // Rückwärts sortieren, vom größten zum kleinsten arr.sort(function(a,b) (return b-a));
Beachten Sie, wie praktisch es ist, in diesem Snippet eine unbenannte Funktion zu verwenden. Die Vergleichsfunktion wird hier nur verwendet, daher ist keine Namensvergabe erforderlich.
concate()-Methode
Die Methode Array.concat() erstellt ein neues Array und gibt es zurück, das die Elemente des ursprünglichen Arrays enthält, für das die Methode concat() aufgerufen wurde, sowie die Werte aller an die Methode concat() übergebenen Argumente. Wenn eines dieser Argumente selbst ein Array ist, werden seine Elemente dem zurückgegebenen Array hinzugefügt. Es ist jedoch zu beachten, dass es keine rekursive Transformation eines Arrays von Arrays in ein eindimensionales Array gibt. Die concat()-Methode verändert das ursprüngliche Array nicht. Nachfolgend einige Beispiele:
Var arr = ; arr.concat(4, 5); // Return arr.concat(); // Gibt arr.concat(,) zurück // Gibt arr.concat(4, ]) zurück // Gibt ] zurück
Slice()-Methode
Die Methode Array.slice() gibt ein Slice oder Subarray des angegebenen Arrays zurück. Die beiden Argumente der Methode definieren den Anfang und das Ende des zurückgegebenen Fragments. Das zurückgegebene Array enthält das Element, dessen Nummer im ersten Argument angegeben ist, sowie alle nachfolgenden Elemente bis (aber nicht einschließlich) des Elements, dessen Nummer im zweiten Argument angegeben ist.
Wenn nur ein Argument angegeben wird, enthält das zurückgegebene Array alle Elemente von der Startposition bis zum Ende des Arrays. Wenn eines der Argumente negativ ist, gibt es die Elementnummer relativ zum Ende des Arrays an. Somit entspricht das Argument -1 dem letzten Element des Arrays und das Argument -3 entspricht dem dritten Element des Arrays vom Ende. Hier sind einige Beispiele:
Var arr = ; arr-Slice(0,3); // Gibt arr.slice(3) zurück; // Gibt arr.slice(1,-1) zurück; // Gibt arr.slice(-3,-2) zurück; // Zurückkehren
splice()-Methode
Die Methode Array.splice() ist eine generische Methode, die Elemente eines Arrays einfügt oder entfernt. Im Gegensatz zu den Methoden „slice()“ und „concat()“ ändert die Methode „splice()“ das ursprüngliche Array, für das sie aufgerufen wurde. Beachten Sie, dass die Methoden splice() und Slice() sehr ähnliche Namen haben, aber völlig unterschiedliche Operationen ausführen.
Die splice()-Methode kann Elemente aus einem Array entfernen, neue Elemente einfügen oder beides gleichzeitig tun. Array-Elemente werden nach Bedarf verschoben, um nach dem Einfügen oder Löschen eine zusammenhängende Sequenz zu bilden.
Das erste Argument der splice()-Methode gibt die Position im Array an, ab der das Einfügen und/oder Löschen durchgeführt wird. Das zweite Argument gibt die Anzahl der Elemente an, die aus dem Array entfernt (ausgeschnitten) werden sollen. Wenn das zweite Argument weggelassen wird, werden alle Array-Elemente vom angegebenen Array bis zum Ende des Arrays entfernt. Die splice()-Methode gibt ein Array der entfernten Elemente oder (wenn keine Elemente entfernt wurden) ein leeres Array zurück.
Die ersten beiden Argumente der splice()-Methode bestimmen die Elemente des Arrays, die entfernt werden sollen. Auf diese Argumente kann eine beliebige Anzahl optionaler Argumente folgen, die die Elemente angeben, die in das Array eingefügt werden sollen, beginnend an der im ersten Argument angegebenen Position.
Var arr = ; arr.splice(4); // Gibt zurück, arr = arr.splice(1,2); // Gibt zurück, arr = arr.splice(1,1); // Kehrt zurück ; arr = arr = ; arr.splice(2,0,"a","b"); // Kehrt zurück ; arr=
push()- und pop()-Methoden
Mit den Methoden push() und pop() können Arrays wie Stapel behandelt werden. Die Methode push() fügt ein oder mehrere neue Elemente am Ende des Arrays hinzu und gibt seine neue Länge zurück. Die Methode pop() führt den umgekehrten Vorgang aus – sie 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 ursprüngliche Array ändern und keine modifizierte Kopie davon erstellen.
unshift()- und shift()-Methoden
Die Methoden unshift() und shift() verhalten sich ähnlich wie push() und pop(), außer dass sie Elemente am Anfang des Arrays einfügen und entfernen, nicht am Ende. Die Methode unshift() verschiebt vorhandene Elemente in Richtung höherer Indizes, um Platz freizugeben, fügt das Element oder die 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 es zurück. Dabei werden alle nachfolgenden Elemente um eine Position nach unten verschoben, um den frei gewordenen Platz am Anfang des Arrays zu füllen.
In dieser Lektion machen wir uns mit Arrays vertraut, lernen, wie man sie erstellt, Operationen an ihren Elementen durchführt und betrachten auch die wichtigsten Methoden und Eigenschaften, die bei der Arbeit mit ihnen zur Verfügung stehen.
Was ist ein Array in JavaScript?
Das Array ist geordnete Sammlung von Werten. Die Werte in dieser Sammlung werden Elemente genannt. Jedes Element im Array hat eine eigene Seriennummer (Nummer), die als Index bezeichnet wird. Indizes werden von 0 an nummeriert.
Die folgende Abbildung zeigt ein numerisches Array mit 5 Elementen. Die Elemente dieses Arrays enthalten die folgenden Daten: 123 (Index 0), 7 (Index 1), 50 (Index 2), -9 (Index 3), 24 (Index 4).
Erstellen (Deklarieren) eines Arrays
Das Erstellen von Arrays in JavaScript erfolgt normalerweise mit Array-Literal.
Ein Array-Literal ist eine eckige Klammer, die eine durch Kommas getrennte Liste von Elementen enthält.
Zum Beispiel:
var leer = ; // leeres Array var zahlen = ; // numerisches Array var arr = ; // Array mit verschiedenen Datentypen
Die Werte in einem JavaScript-Array müssen nicht vom gleichen Typ sein. Diese. Ein Array kann Werte unterschiedlicher Datentypen enthalten.
Auf ein Array-Element wird über seinen Index zugegriffen. Dieser Vorgang wird auch als Indizierungsvorgang bezeichnet.
Zum Beispiel:
// ein Array aus 3 Elementen erstellen var smartphoneColors = ["Black", "White", "Grey"]; // in der Browserkonsole die Werte der SmartphoneColors-Array-Elemente mit den Indizes 0 und 2 anzeigen console.log("Der Wert des SmartphoneColors-Array-Elements mit Index 0: " + SmartphoneColors); // „Wert des SmartphoneColors-Array-Elements bei Index 0: Schwarz“ console.log(“Wert des SmartphoneColors-Array-Elements bei Index 2: „ + SmartphoneColors); // „Der Wert des SmartphoneColors-Array-Elements bei Index 0: Grey“ // den Wert des SmartphoneColors-Array-Elements bei Index 1 in „Red“ ändern SmartphoneColors = „Red“; // ["Schwarz", "Rot", "Grau"] // Setze das SmartphoneColors-Array-Element an Index 3 auf "Blau" SmartphoneColors = "Blue"; // ["Schwarz", "Rot", "Grau", "Blau"]
Als Werte von Array-Elementen können Sie nicht nur statische Werte, sondern auch Ausdrücke verwenden:
var lengthA = 7, widthA = 5; var point = ;
Objekte können als Array-Elementwerte verwendet werden.
Var-Punkte = [ (x1: 5, y1: 3), (x1: 7, y1: 10), (x1: 12; y1: 0) ]; // Array bestehend aus 3 Objekten
Eine andere Möglichkeit, ein Array zu erstellen besteht darin, die Array-Konstruktorfunktion aufzurufen.
Der Aufruf einer Konstruktorfunktion ohne Argumente wird verwendet, um ein leeres Array zu erstellen.
Var empty = new Array(); // leeres Array
Diese Art der Array-Erstellung entspricht einem Literal.
Wenn Sie der Konstruktorfunktion eine Zahl als Argument angeben, wird ein Array erstellt, das aus der angegebenen Anzahl von Elementen besteht. Darüber hinaus haben alle diese Elemente den Wert undefiniert.
Var arr = neues Array(5); // Array aus 5 Elementen (Elementwerte sind undefiniert)
Wenn mehrere Werte oder ein nicht numerischer Wert in Klammern an die Konstruktorfunktion übergeben werden, erstellt diese aus den an sie übergebenen Argumenten ein Array.
Im Gegensatz zu vielen anderen Programmiersprachen ändern Arrays in JavaScript automatisch ihre Größe, d. h. sie sind zunächst dynamisch. Solchen Arrays müssen keine Dimensionen zugewiesen werden. Ein weiteres Unterscheidungsmerkmal von JavaScript-Arrays besteht darin, dass verschiedene Elemente desselben Arrays unterschiedliche Datentypen enthalten können.
Längeneigenschaft (Array-Länge)
Die Bestimmung der Länge eines Arrays (Anzahl der Elemente) erfolgt über die Längeneigenschaft.
//Erstelle ein Array, indem du die Elementwerte in der Array-Funktion auflistest var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //Lassen Sie uns die Länge des volumeHDDs-Arrays der Variablen lengthArray zuweisen var lengthArray = volumeHDDs.length;
So erhalten Sie das erste Element eines Arrays
Der Wert des ersten Elements des Arrays wird durch Angabe der Zahl 0 in eckigen Klammern dieses Arrays ermittelt:
//Erstelle ein Array bestehend aus 3 Elementen var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //Den Wert des ersten Elements des Arrays abrufen var firstValue = volumeHDDs;
So erhalten Sie das letzte Element eines Arrays
Der Wert des letzten Elements des Arrays wird durch Angabe des Ausdrucks array_name.length-1 in eckigen Klammern dieses Arrays ermittelt:
//Erstelle ein Array bestehend aus 3 Elementen var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //Den Wert des letzten Elements des Arrays abrufen var lastValue = volumeHDDs;
Iterieren über ein Array
Das Durchlaufen der Elemente eines Arrays erfolgt mithilfe einer for-Schleife.
Lassen Sie uns beispielsweise alle Elemente des Arrays durchlaufen und ihre Werte in der Browserkonsole anzeigen (F12):
//Erstellen eines Arrays namensStudents bestehend aus 4 Elementen var nameStudents = new Array("Peter","Vasya","Kolya","Maxim"); // über Array-Elemente von 0 bis Array-Länge-1 iterieren für (var i=0; i<= nameStudents.length-1; i++) { console.log(i+1 + " элемент массива = " + nameStudents[i]); }
Was ist der Zweck des Löschoperators?
Der Löschoperator wird nicht verwendet, um ein Element aus einem Array zu entfernen, sondern um einem bestimmten Array-Element den Wert undefiniert zuzuweisen.
Var namePlanets = new Array("Venus", "Merkur", "Erde", "Mars"); NamePlanets löschen; für (var i=0; i<= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }
Funktionen zum Arbeiten mit Arrays (Methoden des Array-Objekts)
Das Array-Objekt enthält die folgenden Methoden (Funktionen) zum Arbeiten mit Arrays:
- Schicht
- unshift
- Scheibe
- spleißen
- Teilt
- umkehren
Push-Methode (Hinzufügen eines Elements am Ende eines Arrays)
Die Push-Methode dient zum Hinzufügen eines Elements am Ende eines Arrays. Der Wert dieses Elements wird als Parameter dieser Methode angegeben. Als Ergebnis gibt die Push-Methode die Anzahl der Elemente im Array unter Berücksichtigung des hinzugefügten Elements zurück.
Var namePlanets = ["Venus", "Merkur", "Erde", "Mars"]; namePlanets.push("Jupiter"); // 5 console.log(namePlanets); // ["Venus", "Merkur", "Erde", "Mars", "Jupiter"]
Pop-Methode (Entfernen des letzten Elements aus dem Array)
Die Pop-Methode dient dazu, das letzte Element aus einem Array zu entfernen. Diese Methode hat keine Parameter. Als Ergebnis wird der Wert des letzten (entfernten) Elements des Arrays zurückgegeben.
Var namePlanets = ["Venus", "Merkur", "Erde", "Mars"]; namePlanets.pop(); // „Mars“ console.log(namePlanets); // ["Venus", "Merkur", "Erde"]
Shift-Methode (Entfernen des ersten Elements aus dem Array)
Die Shift-Methode dient dazu, das erste Element aus einem Array zu entfernen, d. h. Element mit Index 0. Alle anderen Elemente des Arrays werden an den Anfang verschoben, d. h. für jeden von ihnen verringert sich der Index um 1. Diese Methode gibt als Ergebnis den Wert des entfernten Elements zurück.
Var namePlanets = ["Venus", "Merkur", "Erde", "Mars"]; namePlanets.shift(); // „Venus“ console.log(namePlanets); // [„Merkur“, „Erde“, „Mars“]
Unshift-Methode (Hinzufügen eines Elements am Anfang eines Arrays)
Die Unshift-Methode dient dazu, ein Element am Anfang eines Arrays (vor anderen Elementen) hinzuzufügen. Der Wert dieses Elements wird als Parameter dieser Methode angegeben. Als Ergebnis gibt diese Methode die Anzahl der Elemente im Array unter Berücksichtigung des hinzugefügten Elements zurück.
Var namePlanets = ["Merkur", "Erde", "Mars", "Jupiter"]; namePlanets.unshift("Venus"); // 5 console.log(namePlanets); // ["Venus", "Merkur", "Erde", "Mars", "Jupiter"]
Die Slice-Methode (Kopieren eines Abschnitts eines Arrays)
Die Slice-Methode dient zum Kopieren eines Teils eines Arrays. Dabei wird das ursprüngliche Array nicht verändert, sondern als Ergebnis ein neues Array bestehend aus den ausgewählten Elementen zurückgegeben.
Die Slice-Methode hat zwei Parameter:
- 1 Parameter (obligatorisch) – wird verwendet, um den Index des Elements anzugeben, von dem aus mit dem Kopieren von Elementen begonnen werden soll;
- 2. Parameter (optional) – soll den Index des Elements angeben, in das kopiert werden soll (er ist nicht im neuen Array enthalten). Wenn es nicht angegeben ist, werden die Elemente an das Ende des angegebenen Arrays kopiert.
Splice-Methode (Ändern des Inhalts eines Arrays)
Die Splice-Methode dient dazu, den Inhalt eines Arrays zu ändern. Es kann sowohl zum Hinzufügen von Elementen zu einem Array als auch zum Entfernen dieser Elemente verwendet werden.
Die Syntax für die Spleißmethode lautet:
Array.splice(startIndex, deleteCount [, element1[, element2[, ...]]]); /* startIndex (erforderlich) – der Startindex des Elements, ab dem mit der Änderung des Arrays begonnen werden soll. Wenn Sie als startIndex eine Zahl angeben, die größer als die Länge des Arrays ist, wird der Startindex auf das Ende des Arrays gesetzt. Wenn Sie als startIndex eine negative Zahl angeben, wird das Startelement vom Ende an gezählt. deleteCount (erforderlich) – eine Zahl, die angibt, wie viele Elemente aus dem Array entfernt werden sollen. Sollen keine Elemente aus dem Array entfernt werden, muss deleteCount auf 0 gesetzt werden. Danach muss mindestens ein neues Element angegeben werden, das dem Array hinzugefügt werden soll. Wenn Sie als deleteCount eine Zahl angeben, die die Anzahl der verbleibenden Elemente im Array, beginnend mit startIndex, übersteigt, werden diese in diesem Fall trotzdem gelöscht (d. h. alle Elemente bis zum Ende des Arrays, beginnend mit dem Startindex). element1, element2, . .. (optional) – Elemente, die dem Array hinzugefügt werden sollen. */
Beispiele für die Verwendung der Spleißmethode.
Verwendet die Splice-Methode, um einen Teil der Elemente aus einem Array zu entfernen.
Var namePlanets = ["Venus", "Merkur", "Erde", "Mars"]; namePlanets.splice(2, 2); //["Erde", "Mars"] console.log(namePlanets); // ["Venus", "Merkur"]
Verwenden Sie die Splice-Methode, um ein Element aus einem Array zu entfernen und ihm neue hinzuzufügen.
Var namePlanets = ["Venus", "Merkur", "Erde", "Mars"]; namePlanets.splice(1, 1, „Uranus“, „Neptun“, „Saturn“); // ["Merkur"] console.log(namePlanets); // ["Venus", "Uranus", "Neptun", "Saturn", "Erde", "Mars"]
Verwenden Sie die Splice-Methode nur zum Hinzufügen neuer Elemente zu einem Array.
Var namePlanets = ["Jupiter", "Saturn", "Uranus"]; namePlanets.splice(0, 0, „Venus“, „Merkur“, „Erde“, „Mars“); // console.log(namePlanets); // ["Venus", "Merkur", "Erde", "Mars", "Jupiter", "Saturn", "Uranus"]
Join-Methode (Array in String konvertieren)
Die Join-Methode dient dazu, alle Array-Elemente zu einer Zeichenfolge zusammenzufügen.
Die Syntax der Join-Methode lautet:
Array.join(); /* Trennzeichen (optional) – das Trennzeichen, das als Verbindungszeichenfolge zwischen den einzelnen Elementen des Arrays verwendet wird. Wenn dieser Parameter nicht angegeben ist, wird „“,“ als Verbindungszeichenfolge verwendet. Wenn Sie als Parameter einen leeren String angeben, werden die Array-Elemente im zurückgegebenen String durch nichts getrennt */
Var-Beeren = [„Trauben“, „Trauben“, „Johannisbeeren“, „Hagebutten“]; var berriesStr1 = berries.join(); // „Grapes,Grapes,Currants, Rosehips“ var berriesStr2 = berries.join(""); // "GrapesGrapesCurrantRosehip" var berriesStr3 = berries.join(", "); // „Trauben, Trauben, Johannisbeeren, Hagebutten“ var berriesStr4 = berries.join(" + "); // „Trauben + Weintrauben + Johannisbeeren + Hagebutten“
Wenn ein Trennzeichen kein String ist, wird es in einen String umgewandelt.
Var-Beeren = [„Trauben“, „Trauben“, „Johannisbeeren“, „Hagebutten“]; var berriesStr1 = berries.join(false); // „GrapesfalseGrapesfalseCurrantfalseRosehip“ var berriesStr2 = berries.join(4/2); // „Grape2Grape2Currant2Rosehip“ Array-Elemente, deren Wert null oder undefiniert ist, werden in eine leere Zeichenfolge umgewandelt. var arr = ; vararrStr = arr.join(", "); // "0, 5, -4"
String in Array konvertieren – teilen
Die Split-Methode dient dazu, einen String in ein Array umzuwandeln. Diese Methode verfügt über einen Parameter, für den Sie eine Zeichenfolge angeben können, auf deren Grundlage diese Zeichenfolge in ein Array von Zeichenfolgen aufgeteilt wird.
Var strElementComputers = "Systemeinheit, Monitor, Tastatur, Maus, Lautsprecher, Drucker"; var elementComputers = strElementComputers.split(", "); console.log("Anzahl der Elemente im Array: " + elementComputers.length); für (var i=0; i<= elementComputers.length-1; i++) { console.log(i + " элемент массива = " + elementComputers[i]); }
Array-Elemente in umgekehrter Reihenfolge neu anordnen – umgekehrt
Die umgekehrte Methode dient zum Neuanordnen von Array-Elementen in umgekehrter Reihenfolge.
Var namePlanets = new Array("Venus", "Merkur", "Erde", "Mars"); namePlanets.reverse(); console.log("Anzahl der Elemente im Array: " + namePlanets.length); für (var i=0; i<= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }
Array-Elemente sortieren - sort
Die Sortiermethode dient zum Sortieren der Elemente eines Arrays. Standardmäßig sortiert diese Methode das Array als Zeichenfolgen.
Var namePlanets = new Array("Venus", "Merkur", "Erde", "Mars"); namePlanets.sort(); console.log("Anzahl der Elemente im Array: " + namePlanets.length); für (var i=0; i<= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }
