What does the second argument to Array.prototype.reduce do, and what happens if you omit it?

## The signature `Array.prototype.reduce(callback, initialValue?)` collapses ("folds") an array into a single value. The callback receives four arguments: `(accumulator, currentValue, currentIndex, array)`. Whatever the callback returns becomes the accumulator for the next iteration, and the last returned accumulator is `reduce`'s result. `reduce` itself never mutates the source array. ```js [1, 2, 3, 4].reduce((acc, n) => acc + n, 0); // 10 ``` ## With an initial value When you pass `initialValue`, it *is* the accumulator on the first call and iteration begins at index 0. The callback therefore runs exactly once per element: ```js [1, 2, 3].reduce((acc, n) => { console.log(acc, n); return acc + n; }, 10); // logs: 10 1 / 11 2 / 13 3 → result 16 ``` The seed also fixes the accumulator's **type**. That is what lets `reduce` do things `map` and `filter` cannot: fold an array of objects into a number, a string, an object, a `Map`, or a `Set`. ## Without an initial value Omit it and `reduce` uses the array's first element as the starting accumulator and begins iteration at index 1 — one fewer callback invocation: ```js [1, 2, 3].reduce((acc, n) => { console.log(acc, n); return acc + n; }); // logs: 1 2 / 3 3 → result 6 ``` Two consequences follow, and interviewers probe both. **The empty-array throw.** With no seed and no elements there is nothing to start from, so the spec makes it a hard error rather than returning `undefined`: ```js [].reduce((a, b) => a + b); // TypeError: Reduce of empty array with no initial value [].reduce((a, b) => a + b, 0); // 0 ``` This is the classic production bug: the sum works all through development and blows up the first time a filter upstream returns nothing. **The zero-call case.** A single-element array with no seed returns that element directly, without calling the callback at all: ```js ['only'].reduce((a, b) => a + b); // 'only' — callback never runs [42].reduce((a, b) => a * 2); // 42, not 84 ``` So a callback with a side effect or a validation cannot be relied on to run for every element when the seed is missing. ## Type consistency Without a seed the accumulator starts out as an element, which pushes the fold's result toward the element type — fine for summing numbers, wrong for anything else: ```js const words = ['a', 'bb', 'ccc']; words.reduce((total, w) => total + w.length, 0); // 6 — seed makes it a number words.reduce((total, w) => total + w.length); // 'a23' — starts as the string 'a' ``` The second line does not throw; it silently produces a string via `+` concatenation. Bugs of this shape are the strongest argument for always passing the seed. ## reduceRight `Array.prototype.reduceRight` is the same fold walking from the last index toward the first, with identical initial-value rules (omit it and the *last* element seeds the accumulator; an empty array with no seed throws the same `TypeError`). It matters when the operation is not associative or when order is part of the meaning: ```js ['a', 'b', 'c'].reduce((acc, x) => acc + x); // 'abc' ['a', 'b', 'c'].reduceRight((acc, x) => acc + x); // 'cba' ``` A common use is right-to-left function composition, where `reduceRight` expresses `f(g(h(x)))` naturally. ## Practical rule Always pass an explicit initial value unless you deliberately want first-element seeding — and if you do want it, guard the empty case first. The seed documents the accumulator's type, makes the fold total (defined for every input including `[]`), and guarantees the callback runs once per element.