Array.prototype.reduceRight()

callbackFn

Eine Funktion, die für jedes Element im Array ausgeführt wird. Ihr Rückgabewert wird zum Wert des accumulator-Parameters beim nächsten Aufruf von callbackFn. Für den letzten Aufruf wird der Rückgabewert zum Rückgabewert von reduceRight(). Die Funktion wird mit den folgenden Argumenten aufgerufen:

accumulator

Der Wert, der sich aus dem vorherigen Aufruf von callbackFn ergibt. Beim ersten Aufruf ist sein Wert initialValue, falls dieser 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, falls initialValue angegeben ist; andernfalls ist sein Wert das vorletzte Element.

currentIndex

Der Index von currentValue im Array. Beim ersten Aufruf ist sein Wert array.length - 1, falls initialValue angegeben ist, andernfalls array.length - 2.

array

Das Array, auf dem reduceRight() aufgerufen wurde.

initialValue Optional

Wert, der als Akkumulator für den ersten Aufruf von callbackFn 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 einen TypeError.

Der Wert, der sich aus der Reduktion ergibt.

Die reduceRight()-Methode ist eine iterative Methode. Sie führt eine „Reducer“-Callback-Funktion über alle Elemente im Array in absteigender Index-Reihenfolge aus und akkumuliert sie zu einem einzigen Wert. Lesen Sie den Abschnitt iterative Methoden, um mehr darüber zu erfahren, wie diese Methoden im Allgemeinen funktionieren.

callbackFn wird nur für Array-Indizes aufgerufen, denen Werte zugewiesen wurden. Es wird nicht für leere Slots in sparse arrays aufgerufen.

Im Gegensatz zu anderen iterativen Methoden akzeptiert reduceRight() kein thisArg-Argument. callbackFn wird immer mit undefined als this aufgerufen, das durch globalThis ersetzt wird, wenn callbackFn non-strict ist.

Die reduceRight()-Methode ist generisch. Sie erwartet nur, dass der this-Wert eine length-Eigenschaft und Integer-Index-Eigenschaften hat.

Alle Vorbehalte bezüglich reduce, die in when to not use reduce() besprochen werden, gelten auch für reduceRight. Da JavaScript keine Lazy-Evaluation-Semantik hat, besteht kein Leistungsunterschied zwischen reduce und reduceRight.

Der Aufruf der reduceRight callbackFn könnte so aussehen:

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

Beim ersten Aufruf der Funktion können der accumulator und currentValue zwei Werte haben. Wenn ein initialValue bei dem reduceRight-Aufruf übergeben wurde, dann entspricht der accumulator diesem initialValue und currentValue dem letzten Wert im Array. Wenn kein initialValue angegeben wurde, dann entspricht der accumulator dem letzten Wert im Array und currentValue dem vorletzten Wert.

Ist das Array leer und kein initialValue wurde angegeben, wird ein TypeError ausgelöst. Wenn das Array nur ein Element hat (unabhängig von der Position) und kein initialValue angegeben wurde, oder wenn initialValue angegeben ist, aber das Array leer ist, wird der einzelne Wert ohne Aufruf von callbackFn zurückgegeben.

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

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

Der Callback würde vier Mal aufgerufen, wobei die Argumente und Rückgabewerte in jedem Aufruf wie folgt sind:

Der array-Parameter ändert sich während des Prozesses nie – es ist immer [0, 1, 2, 3, 4]. Der von reduceRight zurückgegebene Wert wäre derjenige des letzten Callback-Aufrufs (10).

Hier reduzieren wir dasselbe Array mit demselben Algorithmus, aber mit einem initialValue von 10, das als zweites Argument an reduceRight() übergeben wird:

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

Der diesmal von reduceRight zurückgegebene Wert wäre natürlich 20.

Die Funktionszusammensetzung ist ein Mechanismus zur Kombination von Funktionen, bei dem die Ausgabe jeder Funktion an die nächste weitergegeben wird und das Ergebnis der letzten Funktion das endgültige Resultat ist. In diesem Beispiel verwenden wir reduceRight(), um die Funktionszusammensetzung zu implementieren.

Siehe auch Funktionszusammensetzung auf Wikipedia.

const compose =
  (...args) =>
  (value) =>
    args.reduceRight((acc, fn) => fn(acc), value);

// Increment passed number
const inc = (n) => n + 1;

// Doubles the passed value
const double = (n) => n * 2;

// using composition function
console.log(compose(double, inc)(2)); // 6

// using composition function
console.log(compose(inc, double)(2)); // 5

reduceRight() überspringt fehlende Elemente in lückenhaften Arrays, aber es überspringt keine undefined-Werte.

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

Die reduceRight()-Methode liest die length-Eigenschaft von this und greift dann auf jede Eigenschaft zu, deren Schlüssel ein nicht-negativer Integer ist, der kleiner als length 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

• Polyfill von Array.prototype.reduceRight in core-js
• es-shims Polyfill von Array.prototype.reduceRight
• Indexed collections Leitfaden
• Array
• Array.prototype.map()
• Array.prototype.flat()
• Array.prototype.flatMap()
• Array.prototype.reduce()
• TypedArray.prototype.reduceRight()
• Object.groupBy()
• Map.groupBy()