DiereduceRight()-Methode vonArray-Instanzen wendet eine Funktion gegen einen Akkumulator und jeden Wert des Arrays (von rechts nach links) an, um es auf einen einzelnen Wert zu reduzieren.

Siehe auchArray.prototype.reduce() für von links nach rechts.

Probieren Sie es aus

const array = [  [0, 1],  [2, 3],  [4, 5],];const result = array.reduceRight((accumulator, currentValue) =>  accumulator.concat(currentValue),);console.log(result);// Expected output: Array [4, 5, 2, 3, 0, 1]

Syntax

reduceRight(callbackFn)reduceRight(callbackFn, initialValue)

Parameter

callbackFn

Eine Funktion, die für jedes Element im Array ausgeführt wird. Ihr Rückgabewert wird zum Wert desaccumulator-Parameters beim nächsten Aufruf voncallbackFn. Beim letzten Aufruf wird der Rückgabewert zum Rückgabewert vonreduceRight(). Die Funktion wird mit den folgenden Argumenten aufgerufen:

accumulator

Der Wert, der sich aus dem vorherigen Aufruf voncallbackFn ergibt. Beim ersten Aufruf ist sein WertinitialValue, falls letzterer angegeben ist; andernfalls ist sein Wert das letzte Element des Arrays.

currentValue

Der Wert des aktuellen Elements. Beim ersten Aufruf ist sein Wert das letzte Element, wenninitialValue angegeben ist; andernfalls ist sein Wert das vorletzte Element.

currentIndex

Die Indexposition voncurrentValue im Array. Beim ersten Aufruf ist sein Wertarray.length - 1, wenninitialValue angegeben ist, andernfallsarray.length - 2.

array

Das Array, auf demreduceRight() aufgerufen wurde.

initialValueOptional

Wert, der als Akkumulator beim ersten Aufruf voncallbackFn verwendet wird. Wenn kein Anfangswert angegeben wird, wird das letzte Element im Array verwendet und übersprungen.reduceRight() auf einem leeren Array ohne Anfangswert aufzurufen, erzeugt einenTypeError.

Rückgabewert

Der Wert, der aus der Reduktion resultiert.

Beschreibung

DiereduceRight()-Methode ist eineiterative Methode. Sie führt eine "Reducer"-Callback-Funktion über alle Elemente im Array in absteigender Indexreihenfolge aus und akkumuliert sie zu einem einzigen Wert. Lesen Sie den Abschnittiterative Methoden, um mehr darüber zu erfahren, wie diese Methoden allgemein funktionieren.

callbackFn wird nur für Array-Indizes aufgerufen, denen Werte zugewiesen sind. Es wird nicht für leere Stellen insparse arrays aufgerufen.

Im Gegensatz zu andereniterativen Methoden akzeptiertreduceRight() keinthisArg-Argument.callbackFn wird immer mitundefined alsthis aufgerufen, das ersetzt wird durchglobalThis, wenncallbackFn nicht "strict" ist.

DiereduceRight()-Methode istgenerisch. Sie erwartet nur, dass derthis-Wert einelength-Eigenschaft und ganzzahlig indizierte Eigenschaften hat.

Alle Vorbehalte zureduce, die inwhen to not use reduce() diskutiert werden, gelten auch fürreduceRight. Da JavaScript keine Lazy-Evaluation-Semantik hat, gibt es keinen Leistungsunterschied zwischenreduce undreduceRight.

Beispiele

Wie reduceRight() ohne Anfangswert funktioniert

Der Aufruf der reduceRight-callbackFn könnte folgendermaßen aussehen:

arr.reduceRight((accumulator, currentValue, index, array) => {  // …});

Das erste Mal, wenn die Funktion aufgerufen wird, können deraccumulator undcurrentValue einen von zwei Werten annehmen. Wenn eininitialValue im Aufruf vonreduceRight angegeben wurde, wirdaccumulator gleichinitialValue undcurrentValue wird gleich dem letzten Wert im Array. Wenn keininitialValue angegeben wurde, wirdaccumulator gleich dem letzten Wert im Array undcurrentValue gleich dem vorletzten Wert.

Wenn das Array leer ist und keininitialValue angegeben wurde, wirdTypeError ausgelöst. Wenn das Array nur ein Element hat (unabhängig von der Position) und keininitialValue angegeben wurde oder wenninitialValue angegeben ist, aber das Array leer ist, würde der einzelne Wert ohne Aufruf voncallbackFn zurückgegeben.

Einige Beispiel-Durchläufe der Funktion könnten so aussehen:

[0, 1, 2, 3, 4].reduceRight(  (accumulator, currentValue, index, array) => accumulator + currentValue,);

Das Callback würde viermal aufgerufen, wobei die Argumente und Rückgabewerte bei jedem Aufruf wie folgt sind:

Derarray-Parameter ändert sich während des Prozesses nie - es ist immer[0, 1, 2, 3, 4]. Der vonreduceRight zurückgegebene Wert würde der des letzten Callback-Aufrufs sein (10).

Wie reduceRight() mit einem Anfangswert funktioniert

Hier reduzieren wir dasselbe Array mit demselben Algorithmus, aber mit eineminitialValue von10, der als zweites Argument anreduceRight() übergeben wird:

[0, 1, 2, 3, 4].reduceRight(  (accumulator, currentValue, index, array) => accumulator + currentValue,  10,);

Der vonreduceRight zurückgegebene Wert wäre diesmal natürlich20.

Alle Werte innerhalb eines Arrays aufsummieren

const sum = [0, 1, 2, 3].reduceRight((a, b) => a + b);// sum is 6

Eine Liste von asynchronen Funktionen mit Callbacks in Serie ausführen, wobei ihre Ergebnisse an die nächste weitergegeben werden

const waterfall =  (...functions) =>  (callback, ...args) =>    functions.reduceRight(      (composition, fn) =>        (...results) =>          fn(composition, ...results),      callback,    )(...args);const randInt = (max) => Math.floor(Math.random() * max);const add5 = (callback, x) => {  setTimeout(callback, randInt(1000), x + 5);};const mul3 = (callback, x) => {  setTimeout(callback, randInt(1000), x * 3);};const sub2 = (callback, x) => {  setTimeout(callback, randInt(1000), x - 2);};const split = (callback, x) => {  setTimeout(callback, randInt(1000), x, x);};const add = (callback, x, y) => {  setTimeout(callback, randInt(1000), x + y);};const div4 = (callback, x) => {  setTimeout(callback, randInt(1000), x / 4);};const computation = waterfall(add5, mul3, sub2, split, add, div4);computation(console.log, 5); // Logs 14// same as:const computation2 = (input, callback) => {  const f6 = (x) => div4(callback, x);  const f5 = (x, y) => add(f6, x, y);  const f4 = (x) => split(f5, x);  const f3 = (x) => sub2(f4, x);  const f2 = (x) => mul3(f3, x);  add5(f2, input);};

Unterschied zwischen reduce und reduceRight

const a = ["1", "2", "3", "4", "5"];const left = a.reduce((prev, cur) => prev + cur);const right = a.reduceRight((prev, cur) => prev + cur);console.log(left); // "12345"console.log(right); // "54321"

Definition von komponierbaren Funktionen

Funktionskomposition ist ein Mechanismus zum Kombinieren von Funktionen, bei dem die Ausgabe jeder Funktion in die nächste eingespeist wird und die Ausgabe der letzten Funktion das Endergebnis ist. In diesem Beispiel verwenden wirreduceRight(), um die Funktionskomposition zu implementieren.

Siehe auchFunktionskomposition auf Wikipedia.

const compose =  (...args) =>  (value) =>    args.reduceRight((acc, fn) => fn(acc), value);// Increment passed numberconst inc = (n) => n + 1;// Doubles the passed valueconst double = (n) => n * 2;// using composition functionconsole.log(compose(double, inc)(2)); // 6// using composition functionconsole.log(compose(inc, double)(2)); // 5

Verwendung von reduceRight() mit Sparse-Arrays

reduceRight() überspringt fehlende Elemente in Sparse-Arrays, aber es überspringt nichtundefined-Werte.

console.log([1, 2, , 4].reduceRight((a, b) => a + b)); // 7console.log([1, 2, undefined, 4].reduceRight((a, b) => a + b)); // NaN

Aufruf von reduceRight() bei Nicht-Array-Objekten

DiereduceRight()-Methode liest dielength-Eigenschaft vonthis und greift dann auf jede Eigenschaft zu, deren Schlüssel eine nicht-negative ganze Zahl kleiner alslength ist.

const arrayLike = {  length: 3,  0: 2,  1: 3,  2: 4,  3: 99, // ignored by reduceRight() since length is 3};console.log(Array.prototype.reduceRight.call(arrayLike, (x, y) => x - y));// -1, which is 4 - 3 - 2

Spezifikationen

Browser-Kompatibilität

Siehe auch

• Polyfill vonArray.prototype.reduceRight incore-js
• es-shims Polyfill vonArray.prototype.reduceRight
• Indizierte Sammlungen Leitfaden
• Array
• Array.prototype.map()
• Array.prototype.flat()
• Array.prototype.flatMap()
• Array.prototype.reduce()
• TypedArray.prototype.reduceRight()
• Object.groupBy()
• Map.groupBy()