当接触到reduce方法之后，仿佛从金庸的山洞中学会了旷世武功，读着 manual 久久不愿意翻页。

一、array.reduce 方法概览

reduce() 方法对数组中的每个元素执行一个由您提供的reducer函数(升序执行)，将其结果汇总为单个返回值。

const array1 = [1, 2, 3, 4];const reducer = (accumulator, currentValue) => accumulator + currentValue;// 1 + 2 + 3 + 4console.log(array1.reduce(reducer));// expected output: 10// 5 + 1 + 2 + 3 + 4console.log(array1.reduce(reducer, 5));// expected output: 15

reducer 函数接收4个参数:

Accumulator (acc) (累计器)Current Value (cur) (当前值)Current Index (idx) (当前索引)Source Array (src) (源数组)

您的 reducer 函数的返回值分配给累计器，该返回值在数组的每个迭代中被记住，并最后成为最终的单个结果值。

二、array.reduce 的语法

arr.reduce(callback( accumulator, currentValue, [, index[, array]] )[, initialValue])

参数

callback

执行数组中每个值 (如果没有提供 initialValue则第一个值除外)的函数，包含四个参数：

- accumulator 累计器累计回调的返回值; 它是上一次调用回调时返回的累积值，或initialValue（见于下方）。

- currentValue 数组中正在处理的元素。

- index 可选 数组中正在处理的当前元素的索引。 如果提供了initialValue，则起始索引号为0，否则从索引1起始。

- array可选 调用reduce()的数组initialValue可选

作为第一次调用 callback函数时的第一个参数的值。 如果没有提供初始值，则将使用数组中的第一个元素。 在没有初始值的空数组上调用 reduce 将报错。

返回值

函数累计处理的结果

三、描述

reduce为数组中的每一个元素依次执行callback函数，不包括数组中被删除或从未被赋值的元素，接受四个参数：

accumulator 累计器currentValue 当前值currentIndex 当前索引array 数组

回调函数第一次执行时，accumulator 和currentValue的取值有两种情况：如果调用reduce()时提供了initialValue，accumulator取值为initialValue，currentValue取数组中的第一个值；如果没有提供 initialValue，那么accumulator取数组中的第一个值，currentValue取数组中的第二个值。

注意：如果没有提供initialValue，reduce 会从索引1的地方开始执行 callback 方法，跳过第一个索引。如果提供initialValue，从索引0开始。

如果数组为空且没有提供initialValue，会抛出TypeError 。如果数组仅有一个元素（无论位置如何）并且没有提供initialValue， 或者有提供initialValue但是数组为空，那么此唯一值将被返回并且callback不会被执行。

提供初始值通常更安全，正如下面的例子，如果没有提供initialValue，则可能有四种输出：

var maxCallback = ( acc, cur ) => Math.max( acc.x, cur.x );var maxCallback2 = ( max, cur ) => Math.max( max, cur );// reduce() 没有初始值[ { x: 2 }, { x: 22 }, { x: 42 } ].reduce( maxCallback ); // NaN[ { x: 2 }, { x: 22 }            ].reduce( maxCallback ); // 22[ { x: 2 }                       ].reduce( maxCallback ); // { x: 2 }[                                ].reduce( maxCallback ); // TypeError// map/reduce; 这是更好的方案，即使传入空数组或更大数组也可正常执行[ { x: 22 }, { x: 42 } ].map( el => el.x )                        .reduce( maxCallback2, -Infinity );

四、array.reduce 如何运行？

假如运行下段reduce()代码：

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

callback 被调用四次，每次调用的参数和返回值如下表：

callback

accumulator

currentValue

currentIndex

array

return value

first call

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

由reduce返回的值将是最后一次回调返回值（10）。

你还可以使用箭头函数来代替完整的函数。 下面的代码将产生与上面的代码相同的输出：

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

如果你打算提供一个初始值作为reduce()方法的第二个参数，以下是运行过程及结果：

[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, 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

这种情况下reduce()返回的值是20。

案例01. 数组里所有值的和

var sum = [0, 1, 2, 3].reduce(function (accumulator, currentValue) {  return accumulator + currentValue;}, 0);// 和为 6

你也可以写成箭头函数的形式：

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

reduce的核心就是最终返回一个值，以一个值开始，以一个值结束。

案例02. 累加对象数组里的值

要累加对象数组中包含的值，必须提供初始值，以便各个item正确通过你的函数。

var initialValue = 0;var sum = [{x: 1}, {x:2}, {x:3}].reduce(function (accumulator, currentValue) {    return accumulator + currentValue.x;},initialValue)console.log(sum) // logs 6

你也可以写成箭头函数的形式：

var initialValue = 0;var sum = [{x: 1}, {x:2}, {x:3}].reduce(    (accumulator, currentValue) => accumulator + currentValue.x    ,initialValue);console.log(sum) // logs 6

也可以操作其他数据结构。

案例03. 将二维数组转化为一维

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

你也可以写成箭头函数的形式：

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

案例04.计算数组中每个元素出现的次数

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 }

案例05. 按属性对object分类

var people = [  { name: 'Alice', age: 21 },  { name: 'Max', age: 20 },  { name: 'Jane', age: 20 }];function groupBy(objectArray, property) {  return objectArray.reduce(function (acc, obj) {    var key = obj[property];    if (!acc[key]) {      acc[key] = [];    }    acc[key].push(obj);    return acc;  }, {});}var groupedPeople = groupBy(people, 'age');// groupedPeople is:// {//   20: [//     { name: 'Max', age: 20 },//     { name: 'Jane', age: 20 }//   ],//   21: [{ name: 'Alice', age: 21 }]// }

案例06. 使用扩展运算符和initialValue绑定包含在对象数组中的数组

// friends - 对象数组// where object field "books" - list of favorite booksvar 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 initialValuevar 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'// ]

案例07. 数组去重

注意： 如果你正在使用一个可以兼容Set 和 Array.from() 的环境， 你可以使用let orderedArray = Array.from(new Set(myArray)); 来获得一个相同元素被移除的数组。

let myArray = ['a', 'b', 'a', 'b', 'c', 'e', 'e', 'c', 'd', 'd', 'd', 'd']let myOrderedArray = myArray.reduce(function (accumulator, currentValue) {  if (accumulator.indexOf(currentValue) === -1) {    accumulator.push(currentValue)  }  return accumulator}, [])console.log(myOrderedArray)

let arr = [1,2,1,2,3,5,4,5,3,4,4,4,4];let result = arr.sort().reduce((init, current) => {    if(init.length === 0 || init[init.length-1] !== current) {        init.push(current);    }    return init;}, []);console.log(result); //[1,2,3,4,5]

案例08. 按顺序运行Promise

/** * Runs promises from array of functions that can return promises * in chained manner * * @param {array} arr - promise arr * @return {Object} promise object */function runPromiseInSequence(arr, input) {  return arr.reduce(    (promiseChain, currentFunction) => promiseChain.then(currentFunction),    Promise.resolve(input)  );}// promise function 1function p1(a) {  return new Promise((resolve, reject) => {    resolve(a * 5);  });}// promise function 2function p2(a) {  return new Promise((resolve, reject) => {    resolve(a * 2);  });}// function 3  - will be wrapped in a resolved promise by .then()function f3(a) { return a * 3;}// promise function 4function p4(a) {  return new Promise((resolve, reject) => {    resolve(a * 4);  });}const promiseArr = [p1, p2, f3, p4];runPromiseInSequence(promiseArr, 10)  .then(console.log);   // 1200

案例09. 功能型函数管道

// Building-blocks to use for compositionconst double = x => x + x;const triple = x => 3 * x;const quadruple = x => 4 * x;// Function composition enabling pipe functionalityconst pipe = (...functions) => input => functions.reduce(    (acc, fn) => fn(acc),    input);// Composed functions for multiplication of specific valuesconst multiply6 = pipe(double, triple);const multiply9 = pipe(triple, triple);const multiply16 = pipe(quadruple, quadruple);const multiply24 = pipe(double, triple, quadruple);// Usagemultiply6(6); // 36multiply9(9); // 81multiply16(16); // 256multiply24(10); // 240

案例10. 使用 reduce实现map

if (!Array.prototype.mapUsingReduce) {  Array.prototype.mapUsingReduce = function(callback, thisArg) {    return this.reduce(function(mappedArray, currentValue, index, array) {      mappedArray[index] = callback.call(thisArg, currentValue, index, array)      return mappedArray    }, [])  }}[1, 2, , 3].mapUsingReduce(  (currentValue, index, array) => currentValue + index + array.length) // [5, 7, , 10]