Lassen Sie mich diese Methode heute im Detail vorstellen. Ich hoffe, sie wird Ihnen hilfreich sein. Dies ist die grundlegende Verwendung von Reduce: Reduce ist eine Methode für das Array-Prototypobjekt, die uns beim Betrieb von Arrays hilft. Als Argument nimmt es eine andere Funktion an, die als Reduzierer bezeichnet werden kann. Der Reduzierer benötigt zwei Parameter. Der erste Parameter param1 ist das Ergebnis des letzten Reducer-Laufs. Wenn der Reduzierer zum ersten Mal ausgeführt wird, ist der Standardwert von param1 der Wert des ersten Elements des Arrays. Die Methode „reduce“ durchläuft jedes Element im Array in einer Schleife, genau wie in einer for-Schleife. Und übergeben Sie den aktuellen Wert in der Schleife als Parameter 2. Nach dem Durchlaufen des Arrays gibt Reduzieren das vom letzten Reduzierer berechnete Ergebnis zurück. Schauen wir uns ein detailliertes Beispiel an. Lassen Sie uns als Nächstes untersuchen, wie der obige Code ausgeführt wird. In diesem Code wird der Reduzierer hinzugefügt. Da wir add zum ersten Mal ausführen, wird zunächst das erste Element „a“ im Array als erster Parameter von add behandelt, und dann beginnt die Schleife beim zweiten Element „b“ des Arrays. Diesmal ist „b“ das zweite hinzuzufügende Argument. Nach der ersten Berechnung erhalten wir das Ergebnis „ab“. Dieses Ergebnis wird zwischengespeichert und als Parameter1 in der nächsten Additionsberechnung verwendet. Gleichzeitig wird der dritte Parameter „c“ im Array als Parameter2 von add verwendet. Ebenso wird die Reduzierung durch die Elemente im Array fortgesetzt, wobei „abc“ und „d“ als hinzuzufügende Argumente ausgeführt werden. Nach dem Durchlaufen des letzten Elements im Array wird schließlich das Berechnungsergebnis zurückgegeben. Jetzt haben wir das Ergebnis: 'abcde'. Wir können also sehen, dass Reduzieren auch eine Möglichkeit ist, ein Array zu durchlaufen! Es nimmt nacheinander den Wert jedes Elements im Array und führt die Reduzierfunktion aus. Aber wir können sehen, dass die obige Schleife nicht diese harmonische Schönheit hat. Weil wir das erste Element des Arrays, das „a“ ist, als anfänglichen Parameter1 verwenden und dann das zweite Element des Arrays durchlaufen, um Parameter2 zu erhalten. Tatsächlich können wir den zweiten Parameter in Reduce als Anfangswert von Param1 der Reduzierfunktion angeben, sodass Param2 in einer Schleife ab dem ersten Element des Arrays abgerufen wird. Der Code lautet wie folgt: Dieses Mal rufen wir zuerst den Reduzierer mit „s“ als param1 auf und durchlaufen dann das Array, beginnend mit dem ersten Element. So können wir unser erstes Code-Snippet mit dieser Syntax umschreiben. Als nächstes werden wir mit dem eigentlichen Programmierkapitel beginnen, um die leistungsstarke Kraft von Reduce zu erleben. Was würden Sie tun, wenn wir die Summe aller Elemente in einem Array erhalten möchten? Im Allgemeinen könnten Sie etwa Folgendes schreiben: Natürlich können Sie es auch auf andere Weise schreiben, aber solange Sie eine for-Schleife verwenden, wird der Code überflüssig. Schauen wir uns dann an, was die obige Akkumulationsfunktion bewirkt: Anfangssumme auf Null setzen Holen Sie sich das erste Element im Array und summieren Sie es Zwischenspeichern Sie das Ergebnis des vorherigen Schritts in Summe Nehmen Sie nacheinander andere Elemente im Array heraus und führen Sie die oben genannten Vorgänge aus Endergebnis zurückgeben Wenn wir die obigen Schritte in Worten beschreiben, können wir sehen, dass es offensichtlich ist, dass sie der Verwendung von Reduzieren entsprechen. Daher können wir den obigen Code mithilfe von Reduce umschreiben: Wenn Sie mit der Verwendung von Pfeilfunktionen vertraut sind, sieht der obige Code übersichtlicher aus: Eine Zeile Code und fertig! Natürlich sind kumulative Multiplikation und Akkumulation genau dasselbe: Oftmals müssen wir beim Summieren ein Gewicht hinzufügen, was die Eleganz der Reduzierung besser widerspiegeln kann. Wenn Sie die Maximal- und Minimalwerte eines Arrays erhalten möchten, können Sie Folgendes schreiben: Dies ist das Gleiche wie zuvor. Wenn wir Reduce verwenden, können wir dies in einer Codezeile tun. Wir müssen oft die Anzahl der Vorkommen jedes Elements in einem Array zählen. Die Reduce-Methode hilft uns dabei. Beachten Sie, dass wir zum Speichern statistischer Häufigkeiten Kartenobjekte anstelle von Objekten verwenden, da die Elemente im Array vom Objekttyp sein können und die Schlüssel der Objekte nur Zeichenfolgen- oder Symboltypen sein können. Hier zwei Beispiele: Wenn Sie die Häufigkeit jedes Zeichens in einer Zeichenfolge zählen möchten, können Sie die Zeichenfolge ebenfalls zunächst in ein Zeichenarray konvertieren und dann der oben beschriebenen Methode folgen. Da Zeichentypen als Schlüssel für Objekte verwendet werden können, verwenden wir hier keine Map. Auf jedes Element im Array wird nacheinander durch Reduzieren zugegriffen. Wenn wir feststellen, dass das Element immer noch ein Array ist, rufen wir die flache Methode rekursiv auf.
Vorwort
var arr = [1, 2, 3];
Funktionsreduzierer(parmar1, parmar2){
}
arr.reduce(Reduzierer) var arr = ['a', 'b', 'c', 'd', 'e'];
Funktion add(x, y) {
gib x + y zurück;
}
arr.reduce(add)
var arr = ['a', 'b', 'c', 'd', 'e'];
Funktion add(x, y) {
gib x + y zurück;
}
arr.reduce(add, 's')
var arr = ['a', 'b', 'c', 'd', 'e'];
Funktion add(x, y) {
gib x + y zurück;
}
arr.reduce(add, '') 1. Akkumulation und kumulative Multiplikation
Funktionakkumulation(arr) {
sei Summe = 0;
for (let i = 0; i < arr.length; i++) {
sum = sum + arr[i];
}
Rückgabesumme;
} Funktionakkumulation(arr) {
Funktion Reducer(x, y) {
gib x + y zurück
}
return arr.reduce(reducer, 0);
} Funktionakkumulation(arr) {
return arr.reduce((x, y) => x + y, 0);
}
Funktion Multiplikation(arr) {
return arr.reduce((x, y) => x * y, 1);
} const-Scores = [
{ Punktzahl: 90, Betreff: „HTML“, Gewicht: 0,2 },
{ Punktzahl: 95, Betreff: „CSS“, Gewichtung: 0,3 },
{ Punktzahl: 85, Betreff: „JavaScript“, Gewicht: 0,5 }
];
const result = scores.reduce((x, y) => x + y.score * y.weight, 0); 2. Ermitteln Sie die Maximal- und Minimalwerte eines Arrays
Funktion max(arr){
let max = arr[0];
for (let ele of arr) {
if(ele > max) {
max = ele;
}
}
Rückkehr max;
} sei arr = [3.24, 2.78, 999];
arr.reduce((x, y) => Math.max(x, y));
arr.reduce((x, y) => Math.min(x, y));
3. Berechnen Sie die Häufigkeit des Auftretens von Elementen im Array
Funktion countFrequency(arr) {
return arr.reduce(function(result, ele){
// Beurteilen Sie, ob dieses Element bereits gezählt wurde
if (result.get(ele) != undefiniert) {
/**
* Wenn dieses Element bereits gezählt wurde,
* Erhöhen Sie die Häufigkeit seines Auftretens um 1
*/
result.set(ele, result.get(ele) + 1)
} anders {
/**
* Wenn dieses Element noch nicht gezählt wurde,
* Setzen Sie die Häufigkeit seines Auftretens auf 1
*/
result.set(ele, 1);
}
Ergebnis zurückgeben;
}, neue Map());
}
let str = 'helloworld';
str.split('').reduce((result, currentChar) => {
result[currentChar] ? result[currentChar] ++ : result[currentChar] = 1;
Ergebnis zurückgeben;
}, {}) 
4. Reduzieren mehrerer Arrays
Funktion Flat(arr = []) {
return arr.reduce((t, v) => t.concat(Array.isArray(v) ? Flat(v) : v), [])
} 