JavaScript reduce on Empty Arrays: Choose the Initial Value

Find the empty collection at the reduction boundary#

A nonempty source can become empty after filtering. The MDN error reference describes this failure pattern. Inspect the values passed to reduce, rather than checking only the original array.

In the fixture below, filtering [2, 4] for values greater than ten produces no matches. The unseeded sum throws; the seeded sum returns zero. If an empty selection means “no matching records” rather than a numeric total, return an explicit empty result or throw a domain error before reducing.

Without a supplied initial value, the ECMAScript reduction algorithm searches for the first present element to use as its accumulator. With no such element, it throws. With exactly one present element, it returns that element without calling the reducer.

That last case matters if you put validation inside the callback: a one-element input can bypass it. Validate the input separately when every value must satisfy a contract.

Verify omitted seeds, undefined, and sparse input#

Save this fixture as reduce-empty.mjs and run node reduce-empty.mjs. It was executed during article preparation on October 14, 2026, on macOS with Node.js 24.13.0. The assertions verify ten result-and-callback cases, the filtered sum, and the maximum policy. They use ordinary arrays with no added indexed prototype properties.

1
import assert from 'node:assert/strict';
2
const add = (total, value) => total + value;
3
const selected = [2, 4].filter(value => value > 10);
4
assert.throws(() => selected.reduce(add), TypeError);
5
assert.equal(selected.reduce(add, 0), 0);
6
console.log('filtered sum:', selected.reduce(add, 0));
7

8
function trace(values, ...seed) {
9
  const indices = [];
10
  try {
11
    const result = values.reduce((total, value, index) => {
12
      indices.push(index);
13
      return total + value;
14
    }, ...seed);
15
    return { result, indices };
16
  } catch (error) {
17
    if (!(error instanceof TypeError)) throw error;
18
    return { error: error.name, indices };
19
  }
20
}
21
const cases = [
22
  ['empty / omitted', [], [], { error: 'TypeError', indices: [] }],
23
  ['empty / zero', [], [0], { result: 0, indices: [] }],
24
  ['empty / undefined', [], [undefined], { result: undefined, indices: [] }],
25
  ['one / omitted', [7], [], { result: 7, indices: [] }],
26
  ['two / zero', [7, 3], [0], { result: 10, indices: [0, 1] }],
27
  ['holes / omitted', Array(3), [], { error: 'TypeError', indices: [] }],
28
  ['holes / zero', Array(3), [0], { result: 0, indices: [] }],
29
  ['undefined / omitted', [undefined], [], { result: undefined, indices: [] }],
30
  ['sparse / omitted', [, 7, , 3], [], { result: 10, indices: [3] }],
31
  ['sparse / zero', [, 7, , 3], [0], { result: 10, indices: [1, 3] }],
32
];
33
for (const [label, values, seed, expected] of cases) {
34
  const actual = trace(values, ...seed);
35
  assert.deepEqual(actual, expected);
36
  const result = actual.error ?? String(actual.result);
37
  console.log(`${label}: ${result}; callbacks=[${actual.indices}]`);
38
}
39
function maximumOrNull(values) {
40
  if (values.length === 0) return null;
41
  return values.reduce((max, value) => Math.max(max, value));
42
}
43
assert.equal([-8, -3].reduce((max, value) => Math.max(max, value), 0), 0);
44
assert.equal(maximumOrNull([-8, -3]), -3);
45
assert.equal(maximumOrNull([]), null);
46
console.log('maximum:', maximumOrNull([-8, -3]));
47
console.log('empty maximum:', maximumOrNull([]));
48
console.log('assertions: passed');

Output from that environment:

1
filtered sum: 0
2
empty / omitted: TypeError; callbacks=[]
3
empty / zero: 0; callbacks=[]
4
empty / undefined: undefined; callbacks=[]
5
one / omitted: 7; callbacks=[]
6
two / zero: 10; callbacks=[0,1]
7
holes / omitted: TypeError; callbacks=[]
8
holes / zero: 0; callbacks=[]
9
undefined / omitted: undefined; callbacks=[]
10
sparse / omitted: 10; callbacks=[3]
11
sparse / zero: 10; callbacks=[1,3]
12
maximum: -3
13
empty maximum: null
14
assertions: passed

Passing undefined explicitly supplies a seed. It differs from omitting the argument: the empty reduction returns undefined without a callback. The fixture uses a rest parameter to preserve that argument-presence distinction; a wrapper that always calls reduce(callback, seed) always supplies a seed, even when its caller omitted one.

Array(3) has length three but no present indexed elements in this setup. A length check alone therefore cannot establish that an unseeded reduction has an accumulator. [undefined] has a present element, so its unseeded reduction returns that value. For [, 7, , 3], the unseeded callback visits index 3; supplying zero also visits index 1. MDN’s reduce reference documents callback skipping for empty slots.

If a preceding filter unexpectedly removed legitimate values, fix that selection rule too. The nullish-filter example distinguishes missing values from zero and false; a seed only defines the reduction’s starting state.

Choose an empty-result policy before a seed#

These choices are verified by the fixture or the additional checks described below. The numeric examples assume dense arrays of finite numbers; they do not validate external input or address floating-point precision.

For a maximum, zero introduces a value that may not exist in the input. The fixture checks that reducing [-8, -3] from zero returns zero, while maximumOrNull returns -3. Its empty branch returns null deliberately. Callers must handle that branch rather than treating it as an actual measurement.

maximumOrNull assumes dense finite-number input. It is not a sparse-array validator: a nonempty array of holes passes its length guard and still throws during reduction. If your data can be sparse or contain undefined, normalize and validate it before using this function. Keep the distinction between “absent,” “invalid,” and “zero” in that validation.

The product policy can be checked independently:

1
import assert from 'node:assert/strict';
2
const product = values => values.reduce((total, value) => total * value, 1);
3
assert.equal(product([]), 1);
4
assert.equal(product([2, 3]), 6);
5
assert.equal(product([0, 3]), 0);
6
console.log('product assertions: passed');

This block was also executed in the stated Node environment. Returning one for an empty product is the chosen arithmetic contract; an application that requires at least one factor should reject empty input instead. Choose the result your caller can interpret, then verify empty, singleton, and multi-element inputs with that exact policy.

References:

• ECMAScript: Array.prototype.reduce
• MDN: Reduce of empty array with no initial value
• MDN: Array.prototype.reduce