Array.prototype.reduceRight()

callbackFn

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

accumulator

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

currentIndex

Die Indexposition 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 das reduceRight() aufgerufen wurde.

initialValue Optional

Wert, der als Akkumulator beim ersten Aufruf von callbackFn verwendet wird. Wenn kein Anfangswert angegeben ist, wird das letzte Element im Array verwendet und übersprungen. Das Aufrufen von reduceRight() auf einem leeren Array ohne Anfangswert erzeugt einen TypeError.

Der Wert, der aus der Reduktion resultiert.

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 über iterative Methoden für weitere Informationen darüber, wie diese Methoden allgemein funktionieren.

callbackFn wird nur für Array-Indizes aufgerufen, denen Werte zugewiesen sind. Es wird nicht für leere Plätze 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 nicht streng ist.

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

Alle Vorbehalte bezüglich reduce, die unter when to not use reduce() diskutiert wurden, gelten auch für reduceRight. Da JavaScript keine lazy evaluation Semantik besitzt, gibt es keinen Leistungsunterschied zwischen reduce und reduceRight.

Der Aufruf der reduceRight-callbackFn würde ungefähr 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 im Aufruf von reduceRight angegeben wurde, dann wird accumulator gleich initialValue und currentValue wird gleich dem letzten Wert im Array. Wenn kein initialValue angegeben wurde, dann wird accumulator gleich dem letzten Wert im Array und currentValue wird gleich dem vorletzten Wert.

Wenn das Array leer ist und kein initialValue angegeben wurde, würde 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 wurde, aber das Array leer ist, wird der einzelne Wert zurückgegeben, ohne callbackFn aufzurufen.

Einige Beispiele für die Ausführung der Funktion könnten so aussehen:

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

Der Callback würde viermal aufgerufen, mit den Argumenten und Rückgabewerten in jedem Aufruf wie folgt:

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 der 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 von reduceRight zurückgegebene Wert wäre in diesem Fall natürlich 20.

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

Siehe auch Funktionskomposition 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 dünn besetzten Arrays, überspringt jedoch 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 eine nicht-negative Ganzzahl 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
• Indizierte Sammlungen Leitfaden
• Array
• Array.prototype.map()
• Array.prototype.flat()
• Array.prototype.flatMap()
• Array.prototype.reduce()
• TypedArray.prototype.reduceRight()
• Object.groupBy()
• Map.groupBy()