The array functions are great for all kinds of problems. But what happens when you forget to specify reduce’s second parameter?

To calculate the sum of all numbers in an array, you could use a `for`

-loop:

```
const calculateSum = values => {
let sum = 0;
for (let i = 0; i < values.length; i += 1) {
sum += values[i];
}
return sum;
};
calculateSum([16, 23, 42, 19]); // ⇒ 100
```

Array.prototype.reduce() provides a shorter way to merge an array into a single value. This code does the exact same in fewer lines:

```
const calculateSum = values => values.reduce(
(sum, value) => sum + value,
0
);
calculateSum([16, 23, 42, 19]); // ⇒ 100
```

`reduce`

is available on all arrays in JavaScript. It takes two arguments: a **reducer-function** and an **initial value** for that function. Our **reducer-function** receives two values, called the *accumulator* and the *current value*. It returns a result based on these two values.

Every time the reducer-function is called, it saves its result to the *accumulator*. Going into our first calculation, the accumulator is set to the **initial value**. As `reduce`

steps through the array, it updates the *current value* with each of its entries in turn.

After going through all elements, `reduce`

returns the result of its last calculation.

```
const calculateSum = values => values.reduce(
(sum, value) => sum + value,
0
);
calculateSum([16, 23, 42, 19]); // ⇒ 100
sum | value | sum + value
-------+---------+---------------
0 | 16 | 0 + 16 = 16
16 | 23 | 16 + 23 = 39
39 | 42 | 39 + 32 = 81
81 | 19 | 81 + 19 = 100 ⇒ 100
```

## The fallback “initial value”

When not given an initial value, `reduce`

uses the first element of the array as the initial value:

```
const calculateSum = values => values.reduce(
(sum, value) => sum + value
);
calculateSum([16, 23, 42, 19]);
sum | value | sum + value
-------+---------+---------------
16 | 23 | 16 + 23 = 39
39 | 42 | 39 + 32 = 81
81 | 19 | 81 + 19 = 100 ⇒ 100
// this call is equivalent
calculateSum([23, 42, 19], 16);
```

Instead of starting the calculation at `0`

, we skip a step and begin directly with `16`

. The result is the same, and our calculation requires fewer steps because it does not need to calculate `0 + 16`

.

## Doing more than arithmetic

`reduce`

can do more than basic calculations. We could also write a function that checks if every value in an array is above a certain threshold. Let’s say we want to write a function that returns `false`

if one person in a group is not older than 18 years. We set our initial value to `true`

and set our accumulator to `false`

as soon as one value does not match the condition:

```
const isEverybodyOver18 = ages => ages.reduce(
(accumulator, age) => accumulator && age > 18,
true
);
isEverybodyOver18([16, 23, 42, 19]);
accumulator | age | accumulator && age > 18
---------------+-------+---------------------------
true | 16 | true && 16 > 18 → false
false | 23 | false && 23 > 18 → false
false | 42 | false && 42 > 18 → false
false | 19 | false && 19 > 18 → false ⇒ false
```

If we didn’t set an initial value, reduce would use `16`

as the accumulator’s default value:

```
const isEverybodyOver18 = ages => ages.reduce(
(accumulator, age) => accumulator && age > 18
);
isEverybodyOver18([16, 23, 42, 19]);
accumulator | age | accumulator && age > 18
---------------+-------+---------------------------
16 | 23 | 16 && 23 > 18 → true
true | 42 | true && 42 > 18 → true
true | 19 | true && 19 > 18 → true ⇒ true
// this call is equivalent
isEverybodyOver18([23, 42, 19], 16);
```

Something is not right here. While one of the values is clearly not greater than 18, our function returns `true`

.

We get this incorrect result because the assumed initial value of `16`

is “truthy”. In JavaScript, a chain of `TRUTHY_VALUE && OTHER_VALUE`

always returns `OTHER_VALUE`

. More importantly, the condition `16 > 18`

**is never evaluated** in our faulty `reduce`

-function.

If the values were ordered differently, we would not have noticed this bug. Let’s run the same function again, this time passing in `16`

as the *second* value:

```
const isEverybodyOver18 = ages => ages.reduce(
(accumulator, age) => accumulator && age > 18
);
isEverybodyOver18([23, 16, 42, 19]);
accumulator | age | accumulator && age > 18
---------------+-------+----------------------------
23 | 16 | 23 && 16 > 18 → false
false | 42 | false && 42 > 18 → false
false | 19 | false && 19 > 18 → false ⇒ false
```

This calculation uses `23`

as its initial value, which coincidentally meets the condition of being greater than 18. Again, this first condition of `23 > 18`

**is never evaluated**! It’s pure luck that this call returns the expected result. The result of our function *depends on the order of the elements in the array that is passed to it*. That would be a terrible bug to track down.

It gets crazier. While the previous function checked if *all* values matched a certain condition, imagine we want to check if *any* values match it. We can replace the `&&`

with `||`

to rewrite our function so that it checks if anyone is older than 18 years:

```
const isAnyoneOver18 = ages => ages.reduce(
(accumulator, age) => accumulator || age > 18
);
isAnyoneOver18([16, 23, 42, 19]);
accumulator | age | accumulator || age > 18
---------------+-------+----------------------------
16 | 23 | 16 || 16 > 18 → 16
16 | 42 | 16 || 42 > 18 → 16
16 | 19 | 16 || 19 > 18 → 16 ⇒ 16
```

We no longer receive a Boolean value at all! Because of how `||`

works, our function now returns the first “truthy” value it encounters, giving us `16`

instead of either `true`

or `false`

.

## Solving the problem by avoiding it

We could solve this problem by **always** passing an intial value to `reduce`

through its second parameter. However, there are several cases in which doing so wouldn’t be necessary. When running basic arithmetic, such as addition or multiplication, it is perfectly fine to use `reduce`

without specifying an initial value:

```
const calculateProduct = values => values.reduce(
(product, value) => product * value
);
calculateProduct([16, 23, 42, 19]);
product | value | product * value
-----------+---------+---------------------
16 | 23 | 16 * 23 → 368
368 | 42 | 368 * 42 → 15456
15456 | 19 | 15456 * 19 → 293664 ⇒ 293664
```

If we specified the initial value of `1`

, we would have to do an unnecessary calculation and still get the same result:

```
const calculateProduct = values => values.reduce(
(product, value) => product * value,
1
);
calculateProduct([16, 23, 42, 19]);
product | value | product * value
-----------+---------+---------------------
1 | 16 | 1 * 16 → 16 (unnecessary)
16 | 23 | 16 * 23 → 368
368 | 42 | 368 * 42 → 15456
15456 | 19 | 15456 * 19 → 293664 ⇒ 293664
```

As we saw earlier, it is dangerous to not set an initial value if our reducer-function works with Boolean values. While we could make `reduce`

work in these cases by specifying an initial value for them, JavaScript offers better alternatives for these exact scenarios.

###
`every`

Array.prototype.every() works like a `reduce`

-function that tests all entries against a condition. It always returns a Boolean value.

```
const isEverybodyOver18 = ages => ages.every(
age => age > 18
);
isEverybodyOver18([16, 23, 42, 19]); // ⇒ false
```

Not only does `every`

not require an initial value, the callback also does not use an accumulator. This makes it much easier to read and understand.

###
`some`

While `every`

checks if *all* elements in an array meet a condition, Array.prototype.some() checks if *any* element does:

```
const isAnyoneOver18 = ages => ages.some(
age => age > 18
);
isAnyoneOver18([16, 23, 42, 19]); // ⇒ true
```

This has all the same benefits as `every`

, without the pitfalls we ran into earlier.

The callbacks used in our examples for `every`

and `some`

are identical, so we could even extract them to a shared helper function. If we contrast them with their `reduce`

-equivalents, we get much shorter and more readable code:

```
// before, using `reduce`
const isEverybodyOver18 = ages => ages.reduce(
(accumulator, age) => accumulator && age > 18,
true
);
const isAnyoneOver18 = ages => ages.reduce(
(accumulator, age) => accumulator || age > 18,
false
);
// after, using `every` and `some`
const isOver18 = number => number > 18;
const isEverybodyOver18 = ages => ages.every(isOver18);
const isAnyoneOver18 = ages => ages.some(isOver18);
```

We could now use `isEverybodyOver18`

and `isAnyoneOver18`

exactly as we did before.

If you’re using `reduce`

to calculate Boolean values, see if you can rewrite them to the much simpler alternatives `every`

and `some`

. They are better suited for situations in which `reduce`

can be a little problematic.

Both `every`

and `some`

have broad browser support, even being available in IE9.

## Discussion