Arrays bieten viele Methoden. Der Einfachheit halber werden sie in diesem Kapitel in Gruppen unterteilt.
Wir kennen bereits Methoden, die Elemente am Anfang oder am Ende hinzufügen und entfernen:
arr.push(...items) – fügt Elemente am Ende hinzu,
arr.pop() – extrahiert ein Element vom Ende,
arr.shift() – extrahiert ein Element vom Anfang,
arr.unshift(...items) – fügt Elemente am Anfang hinzu.
Hier sind ein paar andere.
Wie lösche ich ein Element aus dem Array?
Da die Arrays Objekte sind, können wir versuchen, delete zu verwenden:
let arr = ["I", "go", "home"]; arr[1] löschen; // „go“ entfernen alarm( arr[1] ); // undefiniert // now arr = ["I", , "home"]; alarm( arr.length ); // 3
Das Element wurde entfernt, aber das Array enthält immer noch 3 Elemente. Wir können sehen, dass arr.length == 3 .
Das ist natürlich, denn delete obj.key entfernt einen Wert durch den key . Es ist alles, was es tut. Gut für Gegenstände. Bei Arrays möchten wir jedoch normalerweise, dass die restlichen Elemente verschoben werden und den frei gewordenen Platz einnehmen. Wir gehen davon aus, dass wir jetzt ein kürzeres Array haben werden.
Daher sollten spezielle Methoden verwendet werden.
Die arr.splice-Methode ist ein Schweizer Taschenmesser für Arrays. Es kann alles: Elemente einfügen, entfernen und ersetzen.
Die Syntax lautet:
arr.splice(start[, deleteCount, elem1, ..., elemN])
Es ändert arr ab dem start : entfernt deleteCount Elemente und fügt dann elem1, ..., elemN an ihrer Stelle ein. Gibt das Array der entfernten Elemente zurück.
Diese Methode ist anhand von Beispielen leicht zu verstehen.
Beginnen wir mit dem Löschen:
let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // aus Index 1 1 Element entfernen alarm( arr ); // [„Ich“, „JavaScript“]
Einfach, oder? Ausgehend vom Index 1 wurde 1 Element entfernt.
Im nächsten Beispiel entfernen wir 3 Elemente und ersetzen sie durch die anderen beiden:
let arr = ["I", "study", "JavaScript", "right", "now"]; // 3 erste Elemente entfernen und durch andere ersetzen arr.splice(0, 3, „Let's“, „dance“); alarm( arr ) // now ["Let's", "dance", "right", "now"]
Hier können wir sehen, dass splice das Array der entfernten Elemente zurückgibt:
let arr = ["I", "study", "JavaScript", "right", "now"]; // 2 erste Elemente entfernen let Removed = arr.splice(0, 2); Warnung (entfernt); // „I“, „studie“ <-- Array entfernter Elemente
Das splice ermöglicht auch das Einfügen der Elemente ohne Entfernungen. Dazu müssen wir deleteCount auf 0 setzen:
let arr = ["I", "study", "JavaScript"]; // ab Index 2 // 0 löschen // dann füge „complex“ und „sprache“ ein arr.splice(2, 0, „komplex“, „Sprache“); alarm( arr ); // „Ich“, „studieren“, „komplex“, „Sprache“, „JavaScript“
Negative Indizes 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]; // ab Index -1 (einen Schritt vom Ende entfernt) // 0 Elemente löschen, // dann 3 und 4 einfügen arr.splice(-1, 0, 3, 4); alarm( arr ); // 1,2,3,4,5
Die Methode arr.slice ist viel einfacher als die ähnlich aussehende arr.splice .
Die Syntax lautet:
arr.slice([Start], [Ende])
Es gibt ein neues Array zurück, in das alle Elemente vom start bis zum end kopiert werden (ohne end ). Sowohl start als auch end können negativ sein. In diesem Fall wird die Position vom Array-Ende angenommen.
Es ähnelt einer String-Methode str.slice , erstellt jedoch anstelle von Teilstrings Unterarrays.
Zum Beispiel:
let arr = ["t", "e", "s", "t"]; alarm( arr.slice(1, 3) ); // e,s (von 1 nach 3 kopieren) alarm( arr.slice(-2) ); // s,t (von -2 bis zum Ende kopieren)
Wir können es auch ohne Argumente aufrufen: arr.slice() erstellt eine Kopie von arr . Dies wird häufig verwendet, um eine Kopie für weitere Transformationen zu erhalten, die sich nicht auf das ursprüngliche Array auswirken sollten.
Die Methode arr.concat erstellt ein neues Array, das Werte aus anderen Arrays und zusätzliche Elemente enthält.
Die Syntax lautet:
arr.concat(arg1, arg2...)
Es akzeptiert eine beliebige Anzahl von Argumenten – entweder Arrays oder Werte.
Das Ergebnis ist ein neues Array mit Elementen aus arr , dann arg1 , arg2 usw.
Wenn ein Argument argN ein Array ist, werden alle seine Elemente kopiert. Andernfalls wird das Argument selbst kopiert.
Zum Beispiel:
sei arr = [1, 2]; // ein Array erstellen aus: arr und [3,4] alarm( arr.concat([3, 4]) ); // 1,2,3,4 // ein Array erstellen aus: arr und [3,4] und [5,6] alarm( arr.concat([3, 4], [5, 6]) ); // 1,2,3,4,5,6 // Erstelle ein Array aus: arr und [3,4] und füge dann die Werte 5 und 6 hinzu alarm( arr.concat([3, 4], 5, 6) ); // 1,2,3,4,5,6
Normalerweise kopiert es nur Elemente aus Arrays. Andere Objekte werden als Ganzes hinzugefügt, auch wenn sie wie Arrays aussehen:
sei arr = [1, 2];
let arrayLike = {
0: „etwas“,
Länge: 1
};
alarm( arr.concat(arrayLike) ); // 1,2,[Objekt Objekt] …Aber wenn ein Array-ähnliches Objekt eine spezielle Symbol.isConcatSpreadable Eigenschaft hat, dann wird es von concat als Array behandelt: Stattdessen werden seine Elemente hinzugefügt:
sei arr = [1, 2];
let arrayLike = {
0: „etwas“,
1: „sonst“,
[Symbol.isConcatSpreadable]: wahr,
Länge: 2
};
alarm( arr.concat(arrayLike) ); // 1,2,etwas,anderesDie Methode arr.forEach ermöglicht die Ausführung einer Funktion für jedes Element des Arrays.
Die Syntax:
arr.forEach(function(item, index, array) {
// ... etwas mit einem Gegenstand machen
});Dies zeigt beispielsweise jedes Element des Arrays:
// für jeden Elementaufrufalarm ["Bilbo", "Gandalf", "Nazgul"].forEach(alert);
Und dieser Code geht ausführlicher auf ihre Positionen im Zielarray ein:
["Bilbo", "Gandalf", "Nazgul"].forEach((item, index, array) => {
Alert(`${item} befindet sich am Index ${index} in ${array}`);
});Das Ergebnis der Funktion (falls es eines zurückgibt) wird verworfen und ignoriert.
Lassen Sie uns nun Methoden behandeln, die in einem Array suchen.
Die Methoden arr.indexOf und arr.includes haben eine ähnliche Syntax und machen im Wesentlichen dasselbe wie ihre String-Gegenstücke, arbeiten jedoch mit Elementen statt mit Zeichen:
arr.indexOf(item, from) – sucht nach item beginnend mit dem Index from und gibt den Index zurück, in dem es gefunden wurde, andernfalls -1 .
arr.includes(item, from) – sucht nach item ab Index from und gibt true zurück, wenn es gefunden wird.
Normalerweise werden diese Methoden mit nur einem Argument verwendet: dem zu suchenden item . Standardmäßig erfolgt die Suche von Anfang an.
Zum Beispiel:
let arr = [1, 0, false]; alarm( arr.indexOf(0) ); // 1 alarm( arr.indexOf(false) ); // 2 alarm( arr.indexOf(null) ); // -1 alarm( arr.includes(1) ); // WAHR
Bitte beachten Sie, dass indexOf zum Vergleich die strikte Gleichheit === verwendet. Wenn wir also nach false suchen, wird genau false und nicht die Null gefunden.
Wenn wir prüfen möchten, ob item im Array vorhanden ist und den Index nicht benötigen, ist arr.includes vorzuziehen.
Die Methode arr.lastIndexOf ist die gleiche wie indexOf , sucht jedoch von rechts nach links.
let Fruits = ['Apple', 'Orange', 'Apple']
alarm( Fruits.indexOf('Apple') ); // 0 (erster Apfel)
Alert( Fruits.lastIndexOf('Apple') ); // 2 (letzter Apfel) Die includes -Methode verarbeitet NaN korrekt
Ein kleines, aber bemerkenswertes Merkmal von includes ist, dass es NaN im Gegensatz zu indexOf korrekt verarbeitet:
const arr = [NaN]; alarm( arr.indexOf(NaN) ); // -1 (falsch, sollte 0 sein) alarm( arr.includes(NaN) );// true (richtig)
Das liegt daran, dass includes viel später zu JavaScript hinzugefügt wurden und intern den aktuelleren Vergleichsalgorithmus verwenden.
Stellen Sie sich vor, wir haben eine Reihe von Objekten. Wie finden wir ein Objekt mit einem bestimmten Zustand?
Hier erweist sich die Methode arr.find(fn) als nützlich.
Die Syntax lautet:
let result = arr.find(function(item, index, array) {
// wenn true zurückgegeben wird, wird item zurückgegeben und die Iteration wird gestoppt
// für falsches Szenario gibt undefiniert zurück
});Die Funktion wird nacheinander für Elemente des Arrays aufgerufen:
item ist das Element.
index ist sein Index.
array ist das Array selbst.
Wenn true zurückgegeben wird, wird die Suche gestoppt und das item zurückgegeben. Wenn nichts gefunden wird, wird undefined zurückgegeben.
Wir haben beispielsweise ein Array von Benutzern mit jeweils den Feldern id und name . Suchen wir die mit id == 1 :
letuser = [
{id: 1, name: „John“},
{id: 2, name: „Pete“},
{id: 3, Name: „Mary“}
];
let user = users.find(item => item.id == 1);
Alert(Benutzername); // John Im wirklichen Leben sind Arrays von Objekten weit verbreitet, daher ist die find -Methode sehr nützlich.
Beachten Sie, dass wir in dem von uns bereitgestellten Beispiel die Funktion item => item.id == 1 mit einem Argument find . Das ist typisch, andere Argumente dieser Funktion werden selten verwendet.
Die Methode arr.findIndex hat dieselbe Syntax, gibt jedoch den Index zurück, in dem das Element gefunden wurde, und nicht das Element selbst. Der Wert -1 wird zurückgegeben, wenn nichts gefunden wird.
Die Methode arr.findLastIndex ähnelt findIndex , sucht jedoch von rechts nach links, ähnlich wie lastIndexOf .
Hier ist ein Beispiel:
letuser = [
{id: 1, name: „John“},
{id: 2, name: „Pete“},
{id: 3, name: „Mary“},
{id: 4, Name: „John“}
];
// Finden Sie den Index des ersten John
alarm(users.findIndex(user => user.name == 'John')); // 0
// Finden Sie den Index des letzten John
alarm(users.findLastIndex(user => user.name == 'John')); // 3 Die Methode find sucht nach einem einzelnen (ersten) Element, das dafür sorgt, dass die Funktion true zurückgibt.
Wenn es viele gibt, können wir arr.filter(fn) verwenden.
Die Syntax ähnelt find , filter gibt jedoch ein Array aller übereinstimmenden Elemente zurück:
let results = arr.filter(function(item, index, array) {
// wenn wahr, wird das Element in die Ergebnisse verschoben und die Iteration wird fortgesetzt
// gibt ein leeres Array zurück, wenn nichts gefunden wird
});Zum Beispiel:
letuser = [
{id: 1, name: „John“},
{id: 2, name: „Pete“},
{id: 3, Name: „Mary“}
];
// gibt ein Array der ersten beiden Benutzer zurück
let someUsers = users.filter(item => item.id < 3);
alarm(someUsers.length); // 2Kommen wir zu Methoden, die ein Array transformieren und neu anordnen.
Die arr.map-Methode ist eine der nützlichsten und am häufigsten verwendeten.
Es ruft die Funktion für jedes Element des Arrays auf und gibt das Ergebnisarray zurück.
Die Syntax lautet:
let result = arr.map(function(item, index, array) {
// gibt den neuen Wert anstelle von item zurück
});Hier transformieren wir zum Beispiel jedes Element in seine Länge:
let lengths = ["Bilbo", "Gandalf", "Nazgul"].map(item => item.length); Alert(Längen); // 5,7,6
Der Aufruf von arr.sort() sortiert das Array an Ort und Stelle und ändert seine Elementreihenfolge.
Es gibt auch das sortierte Array zurück, aber der zurückgegebene Wert wird normalerweise ignoriert, da arr selbst geändert wird.
Zum Beispiel:
sei arr = [ 1, 2, 15 ]; // Die Methode ordnet den Inhalt von arr neu arr.sort(); alarm( arr ); // 1, 15, 2
Ist Ihnen am Ergebnis etwas Seltsames aufgefallen?
Die Reihenfolge lautete 1, 15, 2 . Falsch. Aber warum?
Die Elemente werden standardmäßig als Zeichenfolgen sortiert.
Im wahrsten Sinne des Wortes werden alle Elemente zum Vergleich in Zeichenfolgen umgewandelt. Für Zeichenfolgen wird die lexikografische Reihenfolge angewendet und tatsächlich "2" > "15" .
Um unsere eigene Sortierreihenfolge zu verwenden, müssen wir eine Funktion als Argument von arr.sort() angeben.
Die Funktion sollte zwei beliebige Werte vergleichen und Folgendes zurückgeben:
Funktion vergleichen(a, b) {
wenn (a > b) 1 zurückgeben; // wenn der erste Wert größer als der zweite ist
if (a == b) return 0; // wenn die Werte gleich sind
if (a < b) return -1; // wenn der erste Wert kleiner als der zweite ist
}Um beispielsweise nach Zahlen zu sortieren:
Funktion vergleichenNumerisch(a, b) {
wenn (a > b) 1 zurückgeben;
if (a == b) return 0;
if (a < b) return -1;
}
sei arr = [ 1, 2, 15 ];
arr.sort(compareNumeric);
alarm(arr); // 1, 2, 15Jetzt funktioniert es wie vorgesehen.
Lassen Sie uns beiseite treten und darüber nachdenken, was passiert. Das arr kann ein Array von allem sein, oder? Es kann Zahlen oder Zeichenfolgen oder Objekte oder was auch immer enthalten. Wir haben eine Reihe einiger Artikel . Um es zu sortieren, benötigen wir eine Ordnungsfunktion , die seine Elemente vergleichen kann. Der Standardwert ist eine Zeichenfolgenreihenfolge.
Die Methode arr.sort(fn) implementiert einen generischen Sortieralgorithmus. Wir müssen uns nicht darum kümmern, wie es intern funktioniert (meistens ein optimierter Quicksort oder Timsort). Es durchläuft das Array, vergleicht seine Elemente mit der bereitgestellten Funktion und ordnet sie neu. Wir müssen lediglich den fn angeben, der den Vergleich durchführt.
Übrigens, wenn wir jemals wissen wollen, welche Elemente verglichen werden, hindert uns nichts daran, sie zu benachrichtigen:
[1, -2, 15, 2, 0, 8].sort(function(a, b) {
alarm( a + " <> " + b );
a - b zurückgeben;
});Der Algorithmus vergleicht dabei möglicherweise ein Element mit mehreren anderen, versucht jedoch, so wenige Vergleiche wie möglich durchzuführen.
Eine Vergleichsfunktion kann eine beliebige Zahl zurückgeben
Eigentlich ist eine Vergleichsfunktion nur erforderlich, um eine positive Zahl für „größer“ und eine negative Zahl für „weniger“ zurückzugeben.
Dadurch können kürzere Funktionen geschrieben werden:
sei arr = [ 1, 2, 15 ];
arr.sort(function(a, b) { return a - b; });
alarm(arr); // 1, 2, 15Pfeil funktioniert optimal
Erinnern Sie sich an Pfeilfunktionen? Wir können sie hier zur besseren Sortierung verwenden:
arr.sort( (a, b) => a - b );
Dies funktioniert genauso wie die längere Version oben.
Verwenden Sie localeCompare für Zeichenfolgen
Erinnern Sie sich an den String-Vergleichsalgorithmus? Standardmäßig werden Buchstaben anhand ihrer Codes verglichen.
Bei vielen Alphabeten ist es besser, die Methode str.localeCompare zu verwenden, um Buchstaben wie Ö korrekt zu sortieren.
Sortieren wir zum Beispiel ein paar Länder auf Deutsch:
let states = ['Österreich', 'Andorra', 'Vietnam']; Alert( Länder.sort( (a, b) => a > b ? 1 : -1) ); // Andorra, Vietnam, Österreich (falsch) alarm( states.sort( (a, b) => a.localeCompare(b) ) ); // Andorra,Österreich,Vietnam (richtig!)
Die Methode arr.reverse kehrt die Reihenfolge der Elemente in arr um.
Zum Beispiel:
sei arr = [1, 2, 3, 4, 5]; arr.reverse(); alarm( arr ); // 5,4,3,2,1
Es gibt auch das Array arr nach der Umkehrung zurück.
Hier ist die Situation aus dem wirklichen Leben. Wir schreiben eine Messaging-App und die Person trägt die durch Kommas getrennte Liste der Empfänger ein: John, Pete, Mary . Aber für uns wäre eine Reihe von Namen viel komfortabler als eine einzelne Zeichenfolge. Wie bekomme ich es?
Die Methode str.split(delim) macht genau das. Es teilt die Zeichenfolge durch das angegebene Trennzeichen delim in ein Array auf.
Im folgenden Beispiel trennen wir durch ein Komma gefolgt von einem Leerzeichen:
let name = 'Bilbo, Gandalf, Nazgul';
let arr = name.split(', ');
for (name of arr) {
Alert( `Eine Nachricht an ${name}.` ); // Eine Nachricht an Bilbo (und andere Namen)
} Die split -Methode verfügt über ein optionales zweites numerisches Argument – eine Begrenzung der Array-Länge. Wenn es bereitgestellt wird, werden die zusätzlichen Elemente ignoriert. In der Praxis wird es jedoch selten verwendet:
let arr = 'Bilbo, Gandalf, Nazgul, Saruman'.split(', ', 2);
alarm(arr); // Bilbo, GandalfIn Buchstaben aufteilen
Der Aufruf von split(s) mit einem leeren s würde die Zeichenfolge in ein Array von Buchstaben aufteilen:
let str = "test";
alarm( str.split('') ); // prüfen Der Aufruf arr.join(glue) bewirkt das Gegenteil von split . Es entsteht eine Reihe von arr -Elementen, die durch glue miteinander verbunden sind.
Zum Beispiel:
let arr = ['Bilbo', 'Gandalf', 'Nazgul'];
let str = arr.join(';'); // füge das Array mit ; in einen String ein
alarm( str ); // Bilbo;Gandalf;Nazgul Wenn wir über ein Array iterieren müssen, können wir forEach , for oder for..of verwenden.
Wenn wir die Daten für jedes Element iterieren und zurückgeben müssen, können wir map verwenden.
Die Methoden arr.reduce und arr.reduceRight gehören ebenfalls zu dieser Art, sind aber etwas komplizierter. Sie werden verwendet, um einen einzelnen Wert basierend auf dem Array zu berechnen.
Die Syntax lautet:
let value = arr.reduce(function(accumulator, item, index, array) {
// ...
}, [anfänglich]);Die Funktion wird nacheinander auf alle Array-Elemente angewendet und „überträgt“ ihr Ergebnis beim nächsten Aufruf.
Argumente:
accumulator – ist das Ergebnis des vorherigen Funktionsaufrufs, gleich initial beim ersten Mal (sofern initial angegeben wird).
item – ist das aktuelle Array-Element.
index – ist seine Position.
array – ist das Array.
Bei der Anwendung der Funktion wird das Ergebnis des vorherigen Funktionsaufrufs als erstes Argument an den nächsten übergeben.
Das erste Argument ist also im Wesentlichen der Akkumulator, der das kombinierte Ergebnis aller vorherigen Ausführungen speichert. Und am Ende wird es das Ergebnis von reduce .
Klingt kompliziert?
Am einfachsten lässt sich das anhand von Beispielen begreifen.
Hier erhalten wir eine Summe eines Arrays in einer Zeile:
sei arr = [1, 2, 3, 4, 5]; let result = arr.reduce((sum, current) => sum + current, 0); Warnung(Ergebnis); // 15
Die an reduce übergebene Funktion verwendet nur zwei Argumente, was normalerweise ausreicht.
Schauen wir uns die Einzelheiten an, was vor sich geht.
Beim ersten Durchlauf ist sum der initial (das letzte Argument von reduce ), gleich 0 , und current ist das erste Array-Element, gleich 1 . Das Funktionsergebnis ist also 1 .
Beim zweiten Durchlauf, sum = 1 , fügen wir das zweite Array-Element ( 2 ) hinzu und kehren zurück.
Beim dritten Durchlauf sum = 3 und wir fügen ein weiteres Element hinzu und so weiter ...
Der Berechnungsablauf:
Oder in Form einer Tabelle, wobei jede Zeile einen Funktionsaufruf für das nächste Array-Element darstellt:
sum | current | Ergebnis | |
|---|---|---|---|
| der erste Anruf | 0 | 1 | 1 |
| der zweite Anruf | 1 | 2 | 3 |
| der dritte Anruf | 3 | 3 | 6 |
| der vierte Anruf | 6 | 4 | 10 |
| der fünfte Anruf | 10 | 5 | 15 |
Hier können wir deutlich sehen, wie das Ergebnis des vorherigen Aufrufs zum ersten Argument des nächsten wird.
Wir können den Anfangswert auch weglassen:
sei arr = [1, 2, 3, 4, 5]; // Anfangswert aus Reduzieren entfernt (keine 0) let result = arr.reduce((sum, current) => sum + current); Warnung( Ergebnis); // 15
Das Ergebnis ist das gleiche. Denn wenn kein Anfangswert vorhanden ist, nimmt reduce das erste Element des Arrays als Anfangswert und beginnt die Iteration ab dem 2. Element.
Die Berechnungstabelle ist dieselbe wie oben, abzüglich der ersten Zeile.
Eine solche Verwendung erfordert jedoch äußerste Sorgfalt. Wenn das Array leer ist, führt reduce ohne Anfangswert zu einem Fehler.
Hier ist ein Beispiel:
sei arr = []; // Fehler: Reduzierung eines leeren Arrays ohne Anfangswert // Wenn der Anfangswert vorhanden wäre, würde Reduce ihn für das leere arr zurückgeben. arr.reduce((sum, current) => sum + current);
Es wird daher empfohlen, immer den Anfangswert anzugeben.
Die Methode arr.reduceRight macht dasselbe, geht aber von rechts nach links.
Arrays bilden keinen eigenen Sprachtyp. Sie basieren auf Objekten.
typeof hilft also nicht dabei, ein einfaches Objekt von einem Array zu unterscheiden:
alarm(typeof {}); // Objekt
alarm(typeof []); // Objekt (gleich) …Aber Arrays werden so oft verwendet, dass es dafür eine spezielle Methode gibt: Array.isArray(value). Es gibt true zurück, wenn der value ein Array ist, andernfalls false .
alarm(Array.isArray({})); // FALSCH
alarm(Array.isArray([])); // WAHR Fast alle Array-Methoden, die Funktionen aufrufen – wie find , filter , map , mit einer bemerkenswerten Ausnahme von sort , akzeptieren einen optionalen zusätzlichen Parameter thisArg .
Dieser Parameter wird in den obigen Abschnitten nicht erläutert, da er selten verwendet wird. Aber der Vollständigkeit halber müssen wir es abdecken.
Hier ist die vollständige Syntax dieser Methoden:
arr.find(func, thisArg); arr.filter(func, thisArg); arr.map(func, thisArg); // ... // thisArg ist das optionale letzte Argument
Der Wert des Parameters thisArg wird für func zu this .
Hier verwenden wir beispielsweise eine Methode des army als Filter und thisArg übergibt den Kontext:
let army = {
Mindestalter: 18,
maximales Alter: 27,
canJoin(user) {
return user.age >= this.minAge && user.age < this.maxAge;
}
};
letuser = [
{Alter: 16},
{Alter: 20},
{Alter: 23},
{Alter: 30}
];
// Benutzer finden, für die army.canJoin true zurückgibt
let Soldiers = users.filter(army.canJoin, army);
alarm(soldiers.length); // 2
alarm(soldaten[0].age); // 20
alarm(soldaten[1].age); // 23 Wenn wir im obigen Beispiel users.filter(army.canJoin) verwenden würden, würde army.canJoin als eigenständige Funktion mit this=undefined aufgerufen werden, was zu einem sofortigen Fehler führen würde.
Ein Aufruf von users.filter(army.canJoin, army) kann durch users.filter(user => army.canJoin(user)) ersetzt werden, was dasselbe bewirkt. Letzteres wird häufiger verwendet, da es für die meisten Menschen etwas einfacher zu verstehen ist.
Ein Spickzettel mit Array-Methoden:
So fügen Sie Elemente hinzu/entfernen:
push(...items) – fügt Elemente am Ende hinzu,
pop() – extrahiert ein Element vom Ende,
shift() – extrahiert ein Element vom Anfang,
unshift(...items) – fügt Elemente am Anfang hinzu.
splice(pos, deleteCount, ...items) – löscht am Index pos deleteCount Elemente und fügt items ein.
slice(start, end) – erstellt ein neues Array und kopiert Elemente vom start bis zum end (nicht inklusive) hinein.
concat(...items) – gibt ein neues Array zurück: kopiert alle Mitglieder des aktuellen und fügt ihm items hinzu. Wenn eines der items ein Array ist, werden seine Elemente übernommen.
So suchen Sie zwischen Elementen:
indexOf/lastIndexOf(item, pos) – sucht nach item ab Position pos und gibt den Index zurück oder -1 , wenn er nicht gefunden wird.
includes(value) – gibt true zurück, wenn das Array value hat, andernfalls false .
find/filter(func) – Elemente durch die Funktion filtern, erste/alle Werte zurückgeben, die dafür sorgen, dass true zurückgegeben wird.
findIndex ähnelt find , gibt jedoch den Index anstelle eines Werts zurück.
So iterieren Sie über Elemente:
forEach(func) – ruft func für jedes Element auf, gibt nichts zurück.
So transformieren Sie das Array:
map(func) – erstellt ein neues Array aus den Ergebnissen des Aufrufs von func für jedes Element.
sort(func) – sortiert das Array direkt und gibt es dann zurück.
reverse() – kehrt das Array direkt um und gibt es dann zurück.
split/join – Konvertieren Sie einen String in ein Array und zurück.
reduce/reduceRight(func, initial) – Berechnen Sie einen einzelnen Wert über das Array, indem Sie func für jedes Element aufrufen und zwischen den Aufrufen ein Zwischenergebnis übergeben.
Zusätzlich:
Array.isArray(value) prüft, ob value ein Array ist. Wenn ja, wird true zurückgegeben, andernfalls false .
Bitte beachten Sie, dass die Methoden sort , reverse und splice das Array selbst verändern.
Diese Methoden werden am häufigsten verwendet und decken 99 % der Anwendungsfälle ab. Aber es gibt noch ein paar andere:
arr.some(fn)/arr.every(fn) Überprüfen Sie das Array.
Die Funktion fn wird für jedes Element des Arrays aufgerufen, ähnlich wie bei map . Wenn eines/alle Ergebnisse true sind, wird true zurückgegeben, andernfalls false .
Diese Methoden verhalten sich in etwa wie || und && Operatoren: Wenn fn einen wahren Wert zurückgibt, gibt arr.some() sofort true zurück und stoppt die Iteration über die restlichen Elemente; Wenn fn einen falschen Wert zurückgibt, gibt arr.every() sofort false zurück und stoppt auch die Iteration über die restlichen Elemente.
Wir können every verwenden, um Arrays zu vergleichen:
Funktion arraysEqual(arr1, arr2) {
return arr1.length === arr2.length && arr1.every((value, index) => value === arr2[index]);
}
alarm( arraysEqual([1, 2], [1, 2])); // WAHR arr.fill(value, start, end) – füllt das Array mit sich wiederholenden value vom start bis zum end .
arr.copyWithin(target, start, end) – kopiert seine Elemente von Position start bis position end in sich selbst , an Position target (überschreibt vorhandene).
arr.flat(tiefe)/arr.flatMap(fn) erstellt ein neues flaches Array aus einem mehrdimensionalen Array.
Die vollständige Liste finden Sie im Handbuch.
Auf den ersten Blick mag es scheinen, dass es so viele Methoden gibt, die man sich nur schwer merken kann. Aber eigentlich ist das viel einfacher.
Sehen Sie sich den Spickzettel an, um sich ihrer bewusst zu werden. Anschließend lösen Sie praxisnah die Aufgaben dieses Kapitels, damit Sie Erfahrung mit Array-Methoden haben.
Wenn Sie danach etwas mit einem Array machen müssen und nicht wissen, wie – kommen Sie hierher, schauen Sie sich den Spickzettel an und finden Sie die richtige Methode. Beispiele helfen Ihnen, es richtig zu schreiben. Schon bald werden Sie sich automatisch an die Methoden erinnern, ohne dass Sie dafür besondere Anstrengungen unternehmen müssen.
Wichtigkeit: 5
Schreiben Sie die Funktion camelize(str) die durch Bindestriche getrennte Wörter wie „my-short-string“ in „myShortString“ in Kamelbuchstaben umwandelt.
Das heißt: Entfernt alle Bindestriche, jedes Wort nach dem Bindestrich wird in Großbuchstaben geschrieben.
Beispiele:
camelize("background-color") == 'backgroundColor';
camelize("list-style-image") == 'listStyleImage';
camelize("-webkit-transition") == 'WebkitTransition'; PS-Hinweis: Verwenden Sie split , um die Zeichenfolge in ein Array aufzuteilen, es umzuwandeln und wieder join .
Öffnen Sie eine Sandbox mit Tests.
Funktion camelize(str) {
Rückgabestr
.split('-') // teilt 'my-long-word' in Array ['my', 'long', 'word'] auf
.Karte(
// schreibt die ersten Buchstaben aller Array-Elemente außer dem ersten groß
// konvertiert ['my', 'long', 'word'] in ['my', 'Long', 'Word']
(Wort, Index) => Index == 0 ? Wort: Wort[0].toUpperCase() + Wort.slice(1)
)
.verbinden(''); // verbindet ['my', 'Long', 'Word'] mit 'myLongWord'
}Öffnen Sie die Lösung mit Tests in einer Sandbox.
Wichtigkeit: 4
Schreiben Sie eine Funktion filterRange(arr, a, b) die ein Array arr abruft, nach Elementen mit Werten größer oder gleich a und kleiner oder gleich b sucht und ein Ergebnis als Array zurückgibt.
Die Funktion sollte das Array nicht ändern. Es sollte das neue Array zurückgeben.
Zum Beispiel:
sei arr = [5, 3, 8, 1]; let filtered = filterRange(arr, 1, 4); alarm( gefiltert ); // 3,1 (übereinstimmende Werte) alarm( arr ); // 5,3,8,1 (nicht geändert)
Öffnen Sie eine Sandbox mit Tests.
Funktion filterRange(arr, a, b) {
// Klammern um den Ausdruck hinzugefügt, um die Lesbarkeit zu verbessern
return arr.filter(item => (a <= item && item <= b));
}
sei arr = [5, 3, 8, 1];
let filtered = filterRange(arr, 1, 4);
alarm( gefiltert ); // 3,1 (übereinstimmende Werte)
alarm( arr ); // 5,3,8,1 (nicht geändert)Öffnen Sie die Lösung mit Tests in einer Sandbox.
Wichtigkeit: 4
Schreiben Sie eine Funktion filterRangeInPlace(arr, a, b) die ein Array arr abruft und daraus alle Werte außer denen zwischen a und b entfernt. Der Test lautet: a ≤ arr[i] ≤ b .
Die Funktion sollte nur das Array ändern. Es sollte nichts zurückgeben.
Zum Beispiel:
sei arr = [5, 3, 8, 1]; filterRangeInPlace(arr, 1, 4); // die Zahlen außer 1 bis 4 entfernt alarm( arr ); // [3, 1]
Öffnen Sie eine Sandbox mit Tests.
Funktion filterRangeInPlace(arr, a, b) {
for (let i = 0; i < arr.length; i++) {
let val = arr[i];
// entfernen, wenn außerhalb des Intervalls
if (val < a || val > b) {
arr.splice(i, 1);
ich--;
}
}
}
sei arr = [5, 3, 8, 1];
filterRangeInPlace(arr, 1, 4); // die Zahlen außer 1 bis 4 entfernt
alarm( arr ); // [3, 1]Öffnen Sie die Lösung mit Tests in einer Sandbox.
Wichtigkeit: 4
sei arr = [5, 2, 1, -10, 8]; // ... Ihr Code, um ihn in absteigender Reihenfolge zu sortieren alarm( arr ); // 8, 5, 2, 1, -10
sei arr = [5, 2, 1, -10, 8]; arr.sort((a, b) => b - a); alarm( arr );
Wichtigkeit: 5
Wir haben ein Array von Strings arr . Wir hätten gerne eine sortierte Kopie davon, aber lassen Sie arr unverändert.
Erstellen Sie eine Funktion copySorted(arr) die eine solche Kopie zurückgibt.
let arr = ["HTML", "JavaScript", "CSS"]; let sorted = copySorted(arr); alarm(sortiert); // CSS, HTML, JavaScript alarm( arr ); // HTML, JavaScript, CSS (keine Änderungen)
Wir können slice() verwenden, um eine Kopie zu erstellen und die Sortierung darauf auszuführen:
Funktion copySorted(arr) {
return arr.slice().sort();
}
let arr = ["HTML", "JavaScript", "CSS"];
let sorted = copySorted(arr);
alarm(sortiert);
alarm( arr );Wichtigkeit: 5
Erstellen Sie eine Konstruktorfunktion „ Calculator , die „erweiterbare“ Taschenrechnerobjekte erstellt.
Die Aufgabe besteht aus zwei Teilen.
Implementieren Sie zunächst die Methode calculate(str) die eine Zeichenfolge wie "1 + 2" im Format „ZAHLOperator NUMBER“ (durch Leerzeichen getrennt) akzeptiert und das Ergebnis zurückgibt. Sollte plus + und minus - verstehen.
Anwendungsbeispiel:
let calc = new Calculator;
alarm( calc.calculate("3 + 7") ); // 10 Fügen Sie dann die Methode addMethod(name, func) hinzu, die dem Rechner eine neue Operation beibringt. Es benötigt den name und die aus zwei Argumenten bestehende Funktion func(a,b) die ihn implementiert.
Fügen wir zum Beispiel die Multiplikation * , die Division / und die Potenz ** hinzu:
let powerCalc = new Calculator;
powerCalc.addMethod("*", (a, b) => a * b);
powerCalc.addMethod("/", (a, b) => a / b);
powerCalc.addMethod("**", (a, b) => a ** b);
let result = powerCalc.calculate("2 ** 3");
Warnung( Ergebnis); // 8In dieser Aufgabe sind keine Klammern oder komplexen Ausdrücke enthalten.
Die Zahlen und der Operator werden durch genau ein Leerzeichen getrennt.
Wenn Sie es hinzufügen möchten, kann es zu einer Fehlerbehandlung kommen.
Öffnen Sie eine Sandbox mit Tests.
Bitte beachten Sie, wie Methoden gespeichert werden. Sie werden einfach zur Eigenschaft this.methods hinzugefügt.
Alle Tests und numerischen Konvertierungen werden in der calculate durchgeführt. In Zukunft kann es erweitert werden, um komplexere Ausdrücke zu unterstützen.
Funktion Calculator() {
this.methods = {
"-": (a, b) => a - b,
„+“: (a, b) => a + b
};
this.calculate = function(str) {
let split = str.split(''),
a = +split[0],
op = split[1],
b = +split[2];
if (!this.methods[op] || isNaN(a) || isNaN(b)) {
NaN zurückgeben;
}
return this.methods[op](a, b);
};
this.addMethod = function(name, func) {
this.methods[name] = func;
};
}Öffnen Sie die Lösung mit Tests in einer Sandbox.
Wichtigkeit: 5
Sie haben ein Array von user , jedes hat user.name . Schreiben Sie den Code, der es in ein Array von Namen umwandelt.
Zum Beispiel:
let john = { name: "John", age: 25 };
let pete = { Name: "Pete", Alter: 30 };
let mary = { Name: „Mary“, Alter: 28 };
let user = [ john, pete, mary ];
let name = /* ... dein Code */
Alert( Namen ); // John, Pete, Mary
let john = { name: "John", age: 25 };
let pete = { Name: "Pete", Alter: 30 };
let mary = { Name: „Mary“, Alter: 28 };
let user = [ john, pete, mary ];
let Namen = Benutzer.map(item => item.name);
Alert( Namen ); // John, Pete, MaryWichtigkeit: 5
Sie haben ein Array von user , jedes hat name , surname und id .
Schreiben Sie den Code, um daraus ein weiteres Array von Objekten mit id und fullName zu erstellen, wobei fullName aus name und surname generiert wird.
Zum Beispiel:
let john = { Name: „John“, Nachname: „Smith“, ID: 1 };
let pete = { name: „Pete“, Nachname: „Hunt“, id: 2 };
let mary = { name: "Mary", Nachname: "Key", id: 3 };
let user = [ john, pete, mary ];
letuserMapped = /* ... Ihr Code ... */
/*
userMapped = [
{ fullName: „John Smith“, id: 1 },
{ fullName: „Pete Hunt“, id: 2 },
{ fullName: „Mary Key“, id: 3 }
]
*/
Alert(usersMapped[0].id) // 1
Alert(usersMapped[0].fullName) // John Smith Eigentlich müssen Sie also ein Array von Objekten einem anderen zuordnen. Versuchen Sie es mit => hier. Es gibt einen kleinen Haken.
let john = { Name: „John“, Nachname: „Smith“, ID: 1 };
let pete = { name: „Pete“, Nachname: „Hunt“, id: 2 };
let mary = { name: „Mary“, Nachname: „Key“, id: 3 };
let user = [ john, pete, mary ];
letuserMapped =user.map(user => ({
vollständiger Name: `${user.name} ${user.surname}`,
id: user.id
}));
/*
userMapped = [
{ fullName: „John Smith“, id: 1 },
{ fullName: „Pete Hunt“, id: 2 },
{ fullName: „Mary Key“, id: 3 }
]
*/
Alert(usersMapped[0].id); // 1
Alert(usersMapped[0].fullName); // John SmithBitte beachten Sie, dass wir in den Pfeilfunktionen zusätzliche Klammern verwenden müssen.
Wir können nicht so schreiben:
letuserMapped =user.map(user => {
vollständiger Name: `${user.name} ${user.surname}`,
id: user.id
}); Wie wir uns erinnern, gibt es zwei Pfeilfunktionen: ohne value => expr und mit value => {...} .
Hier würde JavaScript { als Anfang des Funktionskörpers und nicht als Anfang des Objekts behandeln. Die Problemumgehung besteht darin, sie in die „normalen“ Klammern zu setzen:
letuserMapped =user.map(user => ({
vollständiger Name: `${user.name} ${user.surname}`,
id: user.id
}));Nun gut.
Wichtigkeit: 5
Schreiben Sie die Funktion sortByAge(users) , die ein Array von Objekten mit der Eigenschaft age abruft und sie nach age sortiert.
Zum Beispiel:
let john = { name: "John", age: 25 };
let pete = { Name: "Pete", Alter: 30 };
let mary = { Name: „Mary“, Alter: 28 };
let arr = [ pete, john, mary ];
sortByAge(arr);
// jetzt: [John, Mary, Pete]
alarm(arr[0].name); // John
alarm(arr[1].name); // Maria
alarm(arr[2].name); // Pete
Funktion sortByAge(arr) {
arr.sort((a, b) => a.age - b.age);
}
let john = { name: "John", age: 25 };
let pete = { Name: "Pete", Alter: 30 };
let mary = { Name: „Mary“, Alter: 28 };
let arr = [ pete, john, mary ];
sortByAge(arr);
// jetzt sortiert ist: [John, Mary, Pete]
alarm(arr[0].name); // John
alarm(arr[1].name); // Maria
alarm(arr[2].name); // PeteWichtigkeit: 3
Schreiben Sie die Funktion shuffle(array) die Elemente des Arrays mischt (zufällig neu anordnet).
Mehrere shuffle können zu unterschiedlichen Reihenfolgen der Elemente führen. Zum Beispiel:
sei arr = [1, 2, 3]; shuffle(arr); // arr = [3, 2, 1] shuffle(arr); // arr = [2, 1, 3] shuffle(arr); // arr = [3, 1, 2] // ...
Alle Elementordnungen sollten die gleiche Wahrscheinlichkeit haben. Beispielsweise kann [1,2,3] mit gleicher Wahrscheinlichkeit in jedem Fall in [1,2,3] oder [1,3,2] oder [3,1,2] usw. umgeordnet werden.
Die einfache Lösung könnte sein:
Funktion shuffle(array) {
array.sort(() => Math.random() - 0.5);
}
Sei arr = [1, 2, 3];
Shuffle (arr);
Alarm (arr); Das funktioniert etwas, weil Math.random() - 0.5
Da die Sortierfunktion jedoch nicht so verwendet werden soll, haben nicht alle Permutationen die gleiche Wahrscheinlichkeit.
Betrachten Sie beispielsweise den folgenden Code. Es läuft das 1000000 -Mal shuffle und zählt Erscheinungen aller möglichen Ergebnisse:
Funktion Shuffle (Array) {
array.sort (() => math.random () - 0,5);
}
// Zählungen von Erscheinungen für alle möglichen Permutationen
lass count = {
'123': 0,,
'132': 0,,
'213': 0,,
'231': 0,,
'321': 0,,
'312': 0
};
für (sei i = 0; i <1000000; i ++) {
Sei Array = [1, 2, 3];
Shuffle (Array);
count [array.join ('')] ++;
}
// Zeigen Sie Zählungen aller möglichen Permutationen
für (lass taste in count) {
alert (`$ {key}: $ {count [key]}`);
}Ein Beispielergebnis (hängt vom JS -Motor ab):
123: 250706 132: 124425 213: 249618 231: 124880 312: 125148 321: 125223
Wir können die Verzerrung deutlich sehen: 123 und 213 erscheinen viel häufiger als andere.
Das Ergebnis des Code kann zwischen JavaScript -Motoren variieren, aber wir können bereits erkennen, dass der Ansatz unzuverlässig ist.
Warum funktioniert es nicht? Im Allgemeinen ist sort eine „schwarze Box“: Wir werfen ein Array und eine Vergleichsfunktion hinein und erwarten, dass das Array sortiert wird. Aufgrund der völligen Zufälligkeit des Vergleichs wird die Black Box jedoch verrückt, und wie genau es verrückt wird, hängt von der konkreten Implementierung ab, die sich zwischen Motoren unterscheidet.
Es gibt andere gute Möglichkeiten, die Aufgabe zu erledigen. Zum Beispiel gibt es einen großartigen Algorithmus namens Fisher-Yates Shuffle. Die Idee ist, das Array in umgekehrter Reihenfolge zu spazieren und jedes Element mit einem zufälligen zu tauschen:
Funktion Shuffle (Array) {
für (lass i = array.length-1; i> 0; i--) {
lass J = math.floor (math.random () * (i + 1)); // Zufälliger Index von 0 bis i
// Elemente Array [i] und Array [j] tauschen
// Wir verwenden die Syntax "Destructuring -Zuordnung", um dies zu erreichen
// In späteren Kapiteln finden Sie weitere Details zu dieser Syntax
// Gleiches kann geschrieben werden wie:
// T = Array [i]; Array [i] = Array [j]; Array [j] = t
[Array [i], Array [j]] = [Array [j], Array [i]];
}
}Testen wir es genauso:
Funktion Shuffle (Array) {
für (lass i = array.length-1; i> 0; i--) {
lass J = math.floor (math.random () * (i + 1));
[Array [i], Array [j]] = [Array [j], Array [i]];
}
}
// Zählungen von Erscheinungen für alle möglichen Permutationen
lass count = {
'123': 0,,
'132': 0,,
'213': 0,,
'231': 0,,
'321': 0,,
'312': 0
};
für (sei i = 0; i <1000000; i ++) {
Sei Array = [1, 2, 3];
Shuffle (Array);
count [array.join ('')] ++;
}
// Zeigen Sie Zählungen aller möglichen Permutationen
für (lass taste in count) {
alert (`$ {key}: $ {count [key]}`);
}Die Beispielausgabe:
123: 166693 132: 166647 213: 166628 231: 167517 312: 166199 321: 166316
Sieht jetzt gut aus: Alle Permutationen erscheinen mit der gleichen Wahrscheinlichkeit.
In Bezug auf die Leistung ist der Fisher-Yates-Algorithmus viel besser, es gibt keinen „Sortier“ -Verform.
Bedeutung: 4
Schreiben Sie die Funktion getAverageAge(users) , die eine Reihe von Objekten mit age des Eigenschaft erhält und das Durchschnittsalter zurückgibt.
Die Formel für den Durchschnitt beträgt (age1 + age2 + ... + ageN) / N .
Zum Beispiel:
lass John = {Name: "John", Alter: 25};
lass Pete = {Name: "Pete", Alter: 30};
lass Mary = {Name: "Mary", Alter: 29};
Sei arr = [John, Pete, Mary];
alarm (getaverageage (arr)); // (25 + 30 + 29) / 3 = 28
Funktion getaverageage (Benutzer) {
return user.Reduce ((prev, user) => prev + user.age, 0) / user.Length;
}
lass John = {Name: "John", Alter: 25};
lass Pete = {Name: "Pete", Alter: 30};
lass Mary = {Name: "Mary", Alter: 29};
Sei arr = [John, Pete, Mary];
alarm (getaverageage (arr)); // 28Bedeutung: 4
Sei arr ein Array.
Erstellen Sie eine unique(arr) , die ein Array mit einzigartigen arr -Elementen zurückgeben sollte.
Zum Beispiel:
Funktion einzigartig (arr) {
/ * Ihr Code */
}
Sei Strings = ["Hare", "Krishna", "Hare", "Krishna",
"Krishna", "Krishna", "Hare", "Hare", ": -o"
];
Alarm (einzigartig (Saiten)); // Hare, Krishna ,: -oÖffnen Sie eine Sandkiste mit Tests.
Lassen Sie uns die Array -Gegenstände wandern:
Für jeden Artikel prüfen wir, ob das resultierende Array bereits diesen Artikel hat.
Wenn dies der Fall ist, dann ignorieren Sie, andernfalls die Ergebnisse hinzufügen.
Funktion einzigartig (arr) {
let Ergebnis = [];
für (let str von arr) {
if (! result.includes (str)) {
result.push (str);
}
}
Ergebnis zurückgeben;
}
Sei Strings = ["Hare", "Krishna", "Hare", "Krishna",
"Krishna", "Krishna", "Hare", "Hare", ": -o"
];
Alarm (einzigartig (Saiten)); // Hare, Krishna ,: -oDer Code funktioniert, aber es gibt ein potenzielles Leistungsproblem.
Das Methodeergebnis result.includes(str) führt intern das Array result und vergleicht jedes Element mit str um die Übereinstimmung zu finden.
Wenn also 100 Elemente im result vorhanden sind und niemand mit str übereinstimmt, wird das gesamte result und genau 100 Vergleiche geführt. Und wenn result groß ist, wie 10000 , würde es 10000 Vergleiche geben.
Das ist kein Problem für sich selbst, da JavaScript -Motoren sehr schnell sind, daher ist Walk 10000 Array eine Frage der Mikrosekunden.
Aber wir machen einen solchen Test für jedes Element von arr , in der for Schleife.
Wenn also arr.length 10000 ist, haben wir ungefähr 10000*10000 = 100 Millionen Vergleiche. Das ist eine Menge.
Die Lösung ist also nur für kleine Arrays gut.
Weiter in der Kapitelkarte und in der festgelegten Set werden wir sehen, wie Sie es optimieren können.
Öffnen Sie die Lösung mit Tests in einem Sandkasten.
Bedeutung: 4
Nehmen wir an, wir haben eine Reihe von Benutzern in der Form {id:..., name:..., age:... } erhalten.
Erstellen Sie eine Funktion groupById(arr) die ein Objekt daraus erstellt, mit id als Schlüssel und Array -Elementen als Werte.
Zum Beispiel:
Benutzer = [
{id: 'John', Name: "John Smith", Alter: 20},
{ID: 'Ann', Name: "Ann Smith", Alter: 24},
{ID: 'Pete', Name: "Pete Peterson", Alter: 31},
];
lass userById = GroupById (Benutzer);
/*
// Nach dem Anruf sollten wir haben:
userById = {
John: {id: 'John', Name: "John Smith", Alter: 20},
Ann: {id: 'Ann', Name: "Ann Smith", Alter: 24},
Pete: {ID: 'Pete', Name: "Pete Peterson", Alter: 31},
}
*/Eine solche Funktion ist bei der Arbeit mit Serverdaten sehr praktisch.
In dieser Aufgabe gehen wir davon aus, dass id eindeutig ist. Möglicherweise gibt es keine zwei Array -Elemente mit derselben id .
Bitte verwenden Sie Array .reduce -Methode in der Lösung.
Öffnen Sie eine Sandkiste mit Tests.
Funktion GroupById (Array) {
return array.reduce ((obj, value) => {
obj [value.id] = Wert;
Rückkehr obj;
}, {})
}Öffnen Sie die Lösung mit Tests in einem Sandkasten.