callbackFn

A function to execute for each element in the array. Its return value becomes the value of theaccumulator parameter on the next invocation ofcallbackFn. For the last invocation, the return value becomes the return value ofreduceRight(). The function is called with the following arguments:

accumulator

The value resulting from the previous call tocallbackFn. On the first call, its value isinitialValue if the latter is specified; otherwise its value is the last element of the array.

currentValue

The value of the current element. On the first call, its value is the last element ifinitialValue is specified; otherwise its value is the second-to-last element.

currentIndex

The index position ofcurrentValue in the array. On the first call, its value isarray.length - 1 ifinitialValue is specified, otherwisearray.length - 2.

array

The arrayreduceRight() was called upon.

initialValueOptional

Value to use as accumulator to the first call of thecallbackFn. If no initial value is supplied, the last element in the array will be used and skipped. CallingreduceRight() on an empty array without an initial value creates aTypeError.

The value that results from the reduction.

ThereduceRight() method is aniterative method. It runs a "reducer" callback function over all elements in the array, in descending-index order, and accumulates them into a single value. Read theiterative methods section for more information about how these methods work in general.

callbackFn is invoked only for array indexes which have assigned values. It is not invoked for empty slots insparse arrays.

Unlike otheriterative methods,reduceRight() does not accept athisArg argument.callbackFn is always called withundefined asthis, which gets substituted withglobalThis ifcallbackFn is non-strict.

ThereduceRight() method isgeneric. It only expects thethis value to have alength property and integer-keyed properties.

All caveats aboutreduce discussed inwhen to not use reduce() apply toreduceRight as well. Because JavaScript has no lazy evaluation semantics, there is no performance difference betweenreduce andreduceRight.

The call to the reduceRightcallbackFn would look something like this:

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

The first time the function is called, theaccumulator andcurrentValue can be one of two values. If aninitialValue was provided in the call toreduceRight, thenaccumulator will be equal toinitialValue andcurrentValue will be equal to the last value in the array. If noinitialValue was provided, thenaccumulator will be equal to the last value in the array andcurrentValue will be equal to the second-to-last value.

If the array is empty and noinitialValue was provided,TypeError would be thrown. If the array has only one element (regardless of position) and noinitialValue was provided, or ifinitialValue is provided but the array is empty, the solo value would be returned without callingcallbackFn.

Some example run-throughs of the function would look like this:

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

The callback would be invoked four times, with the arguments and return values in each call being as follows:

Thearray parameter never changes through the process — it's always[0, 1, 2, 3, 4]. The value returned byreduceRight would be that of the last callback invocation (10).

Here we reduce the same array using the same algorithm, but with aninitialValue of10 passed as the second argument toreduceRight():

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

The value returned byreduceRight this time would be, of course,20.

Function composition is a mechanism for combining functions, in which the output of each function is passed into the next one, and the output of the last function is the final result. In this example we usereduceRight() to implement function composition.

See alsoFunction composition on 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() skips missing elements in sparse arrays, but it does not skipundefined values.

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

ThereduceRight() method reads thelength property ofthis and then accesses each property whose key is a nonnegative integer less thanlength.

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 ofArray.prototype.reduceRight incore-js
• es-shims polyfill ofArray.prototype.reduceRight
• Indexed collections guide
• Array
• Array.prototype.map()
• Array.prototype.flat()
• Array.prototype.flatMap()
• Array.prototype.reduce()
• TypedArray.prototype.reduceRight()
• Object.groupBy()
• Map.groupBy()