JavaScript Array reduceRight() Method

What You’ll Learn

reduceRight() is the mirror of reduce(): it folds an array from right to left into one value. This tutorial covers syntax, when order changes the result, reversing arrays, flattening with different element order, and comparison with reduce().

Introduction

You already know reduce() walks the array from index 0 upward. reduceRight() starts at the last index and moves toward 0. The callback signature and accumulator pattern are identical—only the traversal direction changes.

For addition or multiplication, direction often does not matter. For subtraction, string building, or assembling arrays in reverse order, reduceRight() gives different (and intentional) results.

Understanding the reduceRight() Method

array.reduceRight(callback, initialValue?) invokes callback(accumulator, currentValue, index, array) on each element from right to left. Each return value becomes the next accumulator; the last one is the method result.

Without initialValue, the last array element becomes the initial accumulator and the second-to-last element is processed first. On an empty array with no initial value, a TypeError is thrown.

📝 Syntax

General form of Array.prototype.reduceRight:

array.reduceRight(callback(accumulator, currentValue, index, array), initialValue)

Parameters

• callback — returns the next accumulator (same as reduce).
• initialValue — optional starting accumulator.

Return value

• Final accumulator after processing from right to left.
• Original array unchanged.

Common patterns

• arr.reduceRight((a, n) => a + n, 0) — sum (same as reduce).
• arr.reduceRight((a, c) => { a.push(c); return a; }, []) — reversed copy.
• arr.reduceRight((a, c) => a + c, "") — string from right.

Examples Gallery

Open DevTools Console (F12) or use Try-it labs. Example N maps to ?tryit=N.

const numbers = [1, 2, 3, 4, 5];

const sum = numbers.reduceRight((acc, num) => acc + num, 0);

console.log(sum);
// 15

15

const nums = [10, 2, 1];

const fromLeft = nums.reduce((acc, n) => acc - n);
// 10 - 2 - 1 = 7

const fromRight = nums.reduceRight((acc, n) => acc - n);
// 1 - 2 - 10 = -11

console.log("reduce:", fromLeft);
console.log("reduceRight:", fromRight);

reduce: 7
reduceRight: -11

const numbers = [1, 2, 3, 4, 5];

const reversed = numbers.reduceRight((acc, num) => {
  acc.push(num);
  return acc;
}, []);

console.log(reversed);
// [5, 4, 3, 2, 1]

console.log(numbers);
// [1, 2, 3, 4, 5] — unchanged

[5, 4, 3, 2, 1]
[1, 2, 3, 4, 5]

const letters = ["a", "b", "c"];

const left = letters.reduce((acc, ch) => acc + ch, "");
const right = letters.reduceRight((acc, ch) => acc + ch, "");

console.log("reduce:", left);
// "abc"

console.log("reduceRight:", right);
// "cba"

reduce: abc
reduceRight: cba

const nested = [[1, 2], [3, 4], [5, 6]];

const flatLeft = nested.reduce((acc, chunk) => acc.concat(chunk), []);
const flatRight = nested.reduceRight((acc, chunk) => acc.concat(chunk), []);

console.log("reduce:", flatLeft);
// [1, 2, 3, 4, 5, 6]

console.log("reduceRight:", flatRight);
// [5, 6, 3, 4, 1, 2]

reduce: [1, 2, 3, 4, 5, 6]
reduceRight: [5, 6, 3, 4, 1, 2]

🚀 Common Use Cases

• Right-associative math — operations that bind from the right.
• Reverse while folding — build reversed arrays in one pass.
• String assembly — when characters must join from the end.
• Functional compose — mirror of left-fold pipelines (advanced).
• Ordered merging — when chunk sequence must start at the tail.
• Teaching direction — contrast with reduce().

📝 Notes

• Mirror of reduce() with opposite traversal.
• Does not mutate the source array.
• Always return the accumulator from the callback.
• Empty array without initialValue throws TypeError.
• For simple reversal, prefer toReversed() or reverse().
• Commutative ops (sum, product) give same results as reduce.
• ES5—excellent support including IE9+.

💡 Best Practices