Die Matrizen können dank verschiedener Methoden manipuliert werden, von denen ich heute einige erläutern werde, da dieses Thema sehr einfach ist. Lass uns anfangen!
Elemente hinzufügen / entfernen
Wir kennen bereits Methoden, die Elemente am Anfang oder am Ende hinzufügen und entfernen:
- arr.push (… Artikel) - Elemente am Ende hinzufügen,
- arr.pop () - Extrahieren Sie einen Artikel vom Ende,
- arr.shift () - Extrahieren Sie einen Artikel von Anfang an,
- arr.unshift (… Artikel) - Fügen Sie am Anfang Elemente hinzu.
Hier sind jedoch einige andere.
Spleißen
Wie entferne ich ein Element aus dem Array?
Arrays sind Objekte, daher können wir versuchen, delete zu verwenden:
let arr = ["Ich will", "essen", "jetzt"]; arr [2] löschen; // "now" -Alarm entfernen (arr [2]); // undefiniert // jetzt arr = ["Ich will", "essen",]; Alarm (arr.length); // 3
Das Element wurde entfernt, aber das Array hat noch 3 Elemente, das können wir sehen arr.length == 3.
Das ist natürlich, weil obj.key löschen Entfernen Sie einen Wert für die Schlüssel. Es ist alles was es tut. Gut für Gegenstände. Aber für die Arrangements wollen wir im Allgemeinen, dass sich der Rest der Elemente bewegt und den befreiten Platz einnimmt. Wir hoffen, jetzt eine kürzere Matrix zu haben.
Daher müssen spezielle Methoden angewendet werden.
Die Methode arr.splice (str) Es ist wie ein Schweizer Taschenmesser für Arrangements. Sie können alles tun: Elemente hinzufügen, entfernen und einfügen.
Die Syntax lautet:
arr.splice (index [, deleteCount, elem1, ..., elemN])
Es beginnt mit dem Positionsindex: deleteCount-Elemente und fügt sie an ihrer Stelle elem1,…, elemN ein. Gibt das Array gelöschter Elemente zurück.
Diese Methode ist anhand von Beispielen leicht zu verstehen.
Beginnen wir mit dem Entfernen:
let arr = ["I", "study", "JavaScript"]; arr.splice (1, 1); // aus Index 1 entfernen 1 Element alert (arr); // ["I", "JavaScript"]
Einfach richtig? Ab Index 1 wurde Element 1 eliminiert.
Im folgenden Beispiel entfernen wir 3 Elemente und ersetzen sie durch die anderen beiden:
let arr = ["I", "study", "JavaScript", "now", "same"]; // entferne die ersten 3 Elemente und ersetze sie durch ein anderes arr.splice (0, 3, "We", "we tanzte"); alert (arr) // jetzt ["Wir", "wir tanzen", "jetzt", "dasselbe"]
Hier können wir sehen, dass Spleiß das Array der entfernten Elemente zurückgibt:
let arr = ["I", "study", "JavaScript", "now", "same"]; // entferne die ersten beiden Elemente let remove = arr.splice (0, 2); Alarm (entfernt); // "YoI", "study" <- Satz entfernter Elemente
Die Methode spleißen Es ist auch in der Lage, die Elemente ohne Löschung einzufügen. Dafür müssen wir konfigurieren deleteCount zu 0:
let arr = ["I", "study", "JavaScript"]; // aus Index 2 // 0 löschen // dann "komplex" und "Sprache" einfügen. //arr.splice(2, 0, "komplex", "Sprache"); Alarm (arr); // "Ich", "Studium", "Sprache", "Komplex", "JavaScript"
Negative Indizes sind zulässig
Hier und in anderen Array-Methoden sind negative Indizes zulässig. Sie geben die Position vom Ende des Arrays an, wie hier:
sei arr = [1, 2, 5]; // aus Index -1 (einen Schritt vom Ende entfernt) // 0 Elemente löschen, // dann die Punkte 3 und 4 hinzufügen splice.array (-1, 0, 3, 4); Alarm (arr); // 1,2,3,4,5
Scheibe
Die Methode arr.slice es ist viel einfacher als das ähnliche arr.splice.
Die Syntax lautet:
arr.slice (Anfang, Ende);
Gibt ein neues Array zurück, in das alle Elemente kopiert werden, die mit dem Index "begin" bis "end" beginnen (ohne "end"). Sowohl Anfang als auch Ende können negativ sein. In diesem Fall wird die Position vom Ende des Arrays angenommen.
Zum Beispiel:
sei str = "test"; sei arr = ["t", "e", "s", "t"]; alert (str.slice (1, 3)); // ist alert (arr.slice (1, 3)); // e, s alert (str.slice (-2)); // st alert (arr.slice (-2)); // s, t concat
Die Methode arr.concat verbindet die Matrix mit anderen Matrizen und / oder Elementen.
Die Syntax lautet:
arr.concat (arg1, arg2 ...)
Akzeptiert eine beliebige Anzahl von Argumenten, entweder Arrays oder Werte.
Das Ergebnis ist ein neues Array, das Elemente aus arr enthält, also arg1, arg2etc.
Wenn ein Argument ein Array ist oder eine Symbol.isConcatSpreadable-Eigenschaft hat, werden alle seine Elemente kopiert. Andernfalls wird das Argument selbst kopiert.
Zum Beispiel:
sei arr = [1, 2]; // arr mit [3,4] alert zusammenführen (arr.concat ([3, 4])); // 1,2,3,4 // arr mit [3,4] und [5,6] alert zusammenführen (arr.concat ([3, 4], [5, 6])); // 1,2,3,4,5,6 // arr mit [3,4] zusammenführen, dann die Werte 5 und 6 hinzufügen alert (arr.concat ([3, 4], 5, 6)) ;; // 1,2,3,4,5,6
Normalerweise werden nur die Elemente der Arrays kopiert ("erweitert"). Andere Objekte, auch wenn sie wie Arrays aussehen, wurden als Ganzes hinzugefügt:
sei arr = [1, 2]; let arrayHello = {0: "some", Länge: 1}; alert (arr.concat (arrayHello)); // 1,2, [Objekt Objekt] // [1, 2, arrayLike]
Wenn ein Array-ähnliches Objekt jedoch die Eigenschaften Symbol.is, Concat und Spreadable hat, werden stattdessen seine Elemente hinzugefügt:
sei arr = [1, 2]; let arrayHello = {0: "some", 1: "flaso", [Symbol.isConcatSpreadable]: true, length: 2}; alert (arr.concat (arrayHello)); // 1,2, einige, falsch
Durchsuchen der Matrix
Dies sind Methoden zum Suchen nach etwas in einem Array.
indexOf / lastIndexOf und Includes
Methoden arr.indexOf , arr.lastIndexOf y arr.includes Sie haben dieselbe Syntax und machen im Wesentlichen dasselbe wie ihre String-Gegenstücke, aber sie arbeiten eher mit Elementen als mit Zeichen:
- arr.indexOf (item, from) Suche nach einem Artikel vom Index schon seitund gibt den Index zurück, in dem er gefunden wurde, andernfalls -1.
- arr.lastIndexOf (item, from) - Gleich, aber von rechts nach links schauen.
- arr.includes (Artikel, von)- Suchen Artikel vom Index desdeund kehrt zurück wahr wenn gefunden.
Zum Beispiel:
sei arr = [1, 0, false]; alert (arr.indexOf (0)); // 1 alert (arr.indexOf (false)); // 2 alert (arr.indexOf (null)); // -1 alert (arr.includes (1)); // wahr
Beachten Sie, dass die Methoden Vergleiche verwenden ===. Wenn wir also nach false suchen, findet es genau false und nicht null.
Wenn wir auf Aufnahme prüfen wollen und den genauen Index nicht kennen wollen, dann arr.includes Es ist zu bevorzugen.
Ein sehr kleiner Unterschied zu Includes besteht auch darin, dass es korrekt gehandhabt wird NaN, Nicht wie indexOf / lastIndexOf:
const arr = [NaN]; alert (arr.indexOf (NaN)); // -1 (sollte 0 sein, aber ==== Gleichheit funktioniert nicht für NaN) alert (arr.includes (NaN)); // true (korrekt)
find and findIndex
Stellen Sie sich vor, wir haben eine Vielzahl von Objekten. Wie finden wir ein Objekt mit der spezifischen Bedingung?
Hier die Methode arr.find Es ist nützlich.
Die Syntax lautet:
let result = arr.find (Funktion (Element, Index, Array) {// sollte true zurückgeben, wenn das Element das ist, wonach wir suchen});
Die Funktion wird wiederholt für jedes Element des Arrays aufgerufen:
- Artikel ist das Element
- Index ist dein Index.
- Array es ist der Mutterleib selbst.
Wenn er zurückkommt wahrhört die Suche auf, Artikel Es wird zurückgegeben. Wenn nichts gefunden wird, nicht definiert Es wird zurückgegeben.
Zum Beispiel haben wir eine Reihe von Benutzern, die jeweils die Felder id und name enthalten. Lassen Sie uns den mit id == 1 finden:
let users = [{id: 1, name: "Juan"}, {id: 2, name: "Pedro"}, {id: 3, name: "Maria"}]; let users = users.find (item => item.id == 1); alert (users.name); // John
Im wirklichen Leben sind Objektanordnungen eine häufige Sache, so dass die Methode finden Es ist sehr nützlich.
Beachten Sie, dass wir in dem Beispiel eine Funktion bereitgestellt haben finden Einzelargument item => item.id == 1. Andere Parameter von finden Sie werden selten verwendet.
Das arr.findIndex-Methode ist im Wesentlichen dasselbe, gibt jedoch den Index zurück, in dem das Element gefunden wurde, und nicht das Element selbst.
Filter
Das Methode finden sucht nach einem einzelnen (ersten) Element, das die Funktion zurückgibt wahr.
Wenn es viele geben kann, können wir verwenden arr.filter (fn).
Die Syntax ist ungefähr die gleiche wie finden, aber es gibt ein Array von übereinstimmenden Elementen zurück:
let result = arr.filter (Funktion (Element, Index, Array) {// sollte true zurückgeben, wenn das Element den Filter besteht});
Zum Beispiel:
let users = [{id: 1, name: "Juan"}, {id: 2, name: "Pedro"}, {id: 3, name: "Maria"}]; // gebe das Array der ersten Benutzer zurück let someUsers = users.filter (item => item.id <3); alert (someUsers.length); // zwei
