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 aus dem vorherigen Aufruf voncallbackFn resultiert. Beim ersten Aufruf ist sein WertinitialValue, 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, fallsinitialValue angegeben ist; andernfalls ist sein Wert das vorletzte Element.

currentIndex

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

array

Das Array, auf demreduceRight() aufgerufen wurde.

initialValueOptional

Wert, der als Akkumulator beim ersten Aufruf dercallbackFn verwendet wird. Wenn kein Initialwert angegeben ist, wird das letzte Element im Array verwendet und übersprungen. Der Aufruf vonreduceRight() auf einem leeren Array ohne Initialwert erzeugt einenTypeError.

Der Wert, der aus der Reduktion resultiert.

DiereduceRight() Methode ist eineiterative Methode. Sie führt eine "Reduzierer"-Callbackfunktion über alle Elemente im Array in absteigender Index-Reihenfolge aus und akkumuliert sie zu einem einzigen Wert. Lesen Sie den Abschnitt überiterative Methoden für weitere Informationen, wie diese Methoden im Allgemeinen funktionieren.

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

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

DiereduceRight() Methode istgenerisch. Sie erwartet lediglich, dass derthis-Wert einelength-Eigenschaft und Integer-Index-Eigenschaften hat.

Alle Warnhinweise zureduce, die inwann man reduce nicht verwenden sollte diskutiert werden, gelten auch fürreduceRight. Da JavaScript keine Lazy-Evaluations-Semantik hat, besteht kein Leistungsunterschied zwischenreduce undreduceRight.

Der Aufruf derreduceRightcallbackFn sähe ungefähr so aus:

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

Beim ersten Aufruf der Funktion könnenaccumulator undcurrentValue einen von zwei Werten haben. Wenn eininitialValue bei dem Aufruf vonreduceRight angegeben wurde, wirdaccumulator gleichinitialValue undcurrentValue gleich dem letzten Wert im Array sein. Wenn keininitialValue angegeben wurde, wirdaccumulator gleich dem letzten Wert im Array undcurrentValue gleich dem vorletzten Wert sein.

Wenn das Array leer ist und keininitialValue angegeben wurde, würde einTypeError 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, wird der Solo-Wert zurückgegeben, ohne dasscallbackFn aufgerufen wird.

Einige exemplarische Durchläufe der Funktion würden so aussehen:

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

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

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

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 dieses Mal natürlich20.

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

Siehe auchFunktionskomposition in der 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

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

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

DiereduceRight()-Methode liest dielength-Eigenschaft vonthis und greift dann auf jede Eigenschaft zu, deren Schlüssel eine nichtnegative Ganzzahl 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

• 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()