MDN’s new design is in Beta! A sneak peek: https://blog.mozilla.org/opendesign/mdns-new-design-beta/

# Array.prototype.reduce()

The `reduce()` method applies a function against an accumulator and each element in the array (from left to right) to reduce it to a single value.

```var sum = [0, 1, 2, 3].reduce(function(acc, val) {
return acc + val;
}, 0);
// sum is 6

var list1 = [[0, 1], [2, 3], [4, 5]];
var list2 = [0, [1, [2, [3, [4, [5]]]]]];

const flatten = arr => arr.reduce(
(acc, val) => acc.concat(
Array.isArray(val) ? flatten(val) : val
),
[]
);
flatten(list1); // returns [0, 1, 2, 3, 4, 5]
flatten(list2); // returns [0, 1, 2, 3, 4, 5]

/**
* Side Note: Explanation of recursion:
* 1. flatten[] --> []
* 2. flatten[0] --> [] + 0 --> [0]
* 3. flatten[0,1] --> [] + 0 --> [0] + 1 --> [0,1]
* 4. flatten[0,[1]] --> [] + 0 --> [0] + flatten[1] --> [0] + ([]+1) --> [0] + ([1]) --> [0,1]
*/
```

## Syntax

`arr.reduce(callback, [initialValue])`

### Parameters

`callback`
Function to execute on each element in the array, taking four arguments:
`accumulator`
The accumulator accumulates the callback's return values; it is the accumulated value previously returned in the last invocation of the callback, or `initialValue`, if supplied (see below).
`currentValue`
The current element being processed in the array.
`currentIndex`
The index of the current element being processed in the array. Starts at index 0, if an `initialValue` is provided, and at index 1 otherwise.
`array`
The array `reduce` was called upon.
`initialValue`
[Optional] Value to use as the first argument to the first call of the `callback`. If no initial value is supplied, the first element in the array will be used. Calling reduce on an empty array without an initial value is an error.

### Return value

The value that results from the reduction.

## Description

`reduce` executes the `callback` function once for each element present in the array, excluding holes in the array, receiving four arguments:

• `accumulator`
• `currentValue`
• `currentIndex`
• `array`

The first time the callback is called, `accumulator` and `currentValue` can be one of two values. If `initialValue` is provided in the call to `reduce`, then `accumulator` will be equal to `initialValue`, and `currentValue` will be equal to the first value in the array. If no `initialValue` is provided, then `accumulator` will be equal to the first value in the array, and `currentValue` will be equal to the second.

Note: If `initialValue` isn't provided, reduce will execute the callback function starting at index 1, skipping the first index. If `initialValue` is provided, it will start at index 0.

If the array is empty and no `initialValue` is provided, `TypeError` will be thrown. If the array has only one element (regardless of position) and no `initialValue` is provided, or if `initialValue` is provided but the array is empty, the solo value will be returned without calling `callback`.

It is usually safer to provide an initial value because there are three possible outputs without `initialValue`, as shown in the following example.

```var maxCallback = ( acc, cur ) => Math.max( acc.x, cur.x );
var maxCallback2 = ( max, cur ) => Math.max( max, cur );

// reduce() without initialValue
[ { x: 22 }, { x: 42 } ].reduce( maxCallback ); // 42
[ { x: 22 }            ].reduce( maxCallback ); // { x: 22 }
[                      ].reduce( maxCallback ); // TypeError

// map/reduce; better solution, also works for empty arrays
[ { x: 22 }, { x: 42 } ].map( el => el.x )
.reduce( maxCallback2, -Infinity );
```

### How reduce works

Suppose the following use of `reduce` occurred:

```[0, 1, 2, 3, 4].reduce(
function (
`    accumulator,`
`currentValue`,
`currentIndex`,
array
) {
return `accumulator` + currentValue;
}
);
```

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

`callback` `accumulator` `currentValue` `currentIndex` `array` return value
first call `0` `1` `1` `[0, 1, 2, 3, 4]` `1`
second call `1` `2` `2` `[0, 1, 2, 3, 4]` `3`
third call `3` `3` `3` `[0, 1, 2, 3, 4]` `6`
fourth call `6` `4` `4` `[0, 1, 2, 3, 4]` `10`

The value returned by `reduce` would be that of the last callback invocation (`10`).

You can also provide an Arrow Function in lieu of a full function. The code below will produce the same output as the code in the block above:

```[0, 1, 2, 3, 4].reduce( (prev, curr) => prev + curr );
```

If you were to provide an initial value as the second argument to `reduce`, the result would look like this:

```[0, 1, 2, 3, 4].reduce(
(`accumulator`, currentValue, currentIndex, array) => {
return `accumulator` + currentValue;
},
10
);
```
`callback` `accumulator` `currentValue` `currentIndex` `array` return value
first call `10` `0` `0` `[0, 1, 2, 3, 4]` `10`
second call `10` `1` `1` `[0, 1, 2, 3, 4]` `11`
third call `11` `2` `2` `[0, 1, 2, 3, 4]` `13`
fourth call `13` `3` `3` `[0, 1, 2, 3, 4]` `16`
fifth call `16` `4` `4` `[0, 1, 2, 3, 4]` `20`

The value returned by `reduce` in this case would be `20`.

## Examples

### Sum all the values of an array

```var sum = [0, 1, 2, 3].reduce(function (a, b) {
return a + b;
}, 0);
// sum is 6
```

Alternatively, written with an arrow function:

```var total = [ 0, 1, 2, 3 ].reduce(
( acc, cur ) => acc + cur,
0
);```

### Flatten an array of arrays

```var flattened = [[0, 1], [2, 3], [4, 5]].reduce(
function(a, b) {
return a.concat(b);
},
[]
);
// flattened is [0, 1, 2, 3, 4, 5]
```

Alternatively, written with an arrow function:

```var flattened = [[0, 1], [2, 3], [4, 5]].reduce(
( acc, cur ) => acc.concat(cur),
[]
);
```

### Counting instances of values in an object

```var names = ['Alice', 'Bob', 'Tiff', 'Bruce', 'Alice'];

var countedNames = names.reduce(function (allNames, name) {
if (name in allNames) {
allNames[name]++;
}
else {
allNames[name] = 1;
}
return allNames;
}, {});
// countedNames is:
// { 'Alice': 2, 'Bob': 1, 'Tiff': 1, 'Bruce': 1 }
```

### Bonding arrays contained in an array of objects using the spread operator and initialValue

```// friends - an array of objects
// where object field "books" - list of favorite books
var friends = [{
name: 'Anna',
books: ['Bible', 'Harry Potter'],
age: 21
}, {
name: 'Bob',
books: ['War and peace', 'Romeo and Juliet'],
age: 26
}, {
name: 'Alice',
books: ['The Lord of the Rings', 'The Shining'],
age: 18
}];

// allbooks - list which will contain all friends' books +
// additional list contained in initialValue
var allbooks = friends.reduce(function(prev, curr) {
return [...prev, ...curr.books];
}, ['Alphabet']);

// allbooks = [
//   'Alphabet', 'Bible', 'Harry Potter', 'War and peace',
//   'Romeo and Juliet', 'The Lord of the Rings',
//   'The Shining'
// ]```

## Polyfill

```// Production steps of ECMA-262, Edition 5, 15.4.4.21
// Reference: http://es5.github.io/#x15.4.4.21
// https://tc39.github.io/ecma262/#sec-array.prototype.reduce
if (!Array.prototype.reduce) {
Object.defineProperty(Array.prototype, 'reduce', {
value: function(callback /*, initialValue*/) {
if (this === null) {
throw new TypeError( 'Array.prototype.reduce ' +
'called on null or undefined' );
}
if (typeof callback !== 'function') {
throw new TypeError( callback +
' is not a function');
}

// 1. Let O be ? ToObject(this value).
var o = Object(this);

// 2. Let len be ? ToLength(? Get(O, "length")).
var len = o.length >>> 0;

// Steps 3, 4, 5, 6, 7
var k = 0;
var value;

if (arguments.length >= 2) {
value = arguments[1];
} else {
while (k < len && !(k in o)) {
k++;
}

// 3. If len is 0 and initialValue is not present,
//    throw a TypeError exception.
if (k >= len) {
throw new TypeError( 'Reduce of empty array ' +
'with no initial value' );
}
value = o[k++];
}

// 8. Repeat, while k < len
while (k < len) {
// a. Let Pk be ! ToString(k).
// b. Let kPresent be ? HasProperty(O, Pk).
// c. If kPresent is true, then
//    i.  Let kValue be ? Get(O, Pk).
//    ii. Let accumulator be ? Call(
//          callbackfn, undefined,
//          « accumulator, kValue, k, O »).
if (k in o) {
value = callback(value, o[k], k, o);
}

// d. Increase k by 1.
k++;
}

// 9. Return accumulator.
return value;
}
});
}
```

If you need to support truly obsolete JavaScript engines that don't support `Object.defineProperty`, it's best not to polyfill `Array.prototype` methods at all, as you can't make them non-enumerable.

## Specifications

Specification Status Comment
ECMAScript 5.1 (ECMA-262)
The definition of 'Array.prototype.reduce' in that specification.
Standard Initial definition. Implemented in JavaScript 1.8.
ECMAScript 2015 (6th Edition, ECMA-262)
The definition of 'Array.prototype.reduce' in that specification.
Standard
ECMAScript Latest Draft (ECMA-262)
The definition of 'Array.prototype.reduce' in that specification.
Draft

## Browser compatibility

Feature Chrome Edge Firefox (Gecko) Internet Explorer Opera Safari
Basic support (Yes) (Yes) 3.0 (1.9) 9 10.5 4.0
Feature Android Chrome for Android Edge Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
Basic support (Yes) (Yes) (Yes) (Yes) (Yes) (Yes) (Yes)