js的reduce用法

Array.reduce( Function, initValue )
两个参数都非常的重要（虽然第二个可有可无）

Function: 不用说，肯定是个回调函数。由开发者提供 reduce 来回调
initValue: 第一次回调 Function 时会将 initValue 传入到 Function 的第一个参数中 function(pre, cur, index, arr)

pre: 上一次的结果集，这个值通常会使用 initValue 作为第一次的默认参数，不过，我上面也有提到，当 initValue 没有传入参数时这个值将会是数组的第一个值
cur: 当前元素，与我们使用 forEach/map 时的 item 一样。都是当前循环到的那个对象
index: 当前元素的索引
arr: 当前元素所属的数组

循环累加

入参：[1,2,3,4,5]
出参：15

let arr1 = [1, 2, 3, 4, 5]

var result = arr1.reduce((pre, cur) => pre + cur)

console.log(result) // 15

处理二维数组扁平化

要点：concat合并数组
入参：[[1,2,3],[4,5,6],[7,8,9]]
出参：[1, 2, 3, 4, 5, 6, 7, 8, 9]

let arr2 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

var result = arr2.reduce((pre, cur) => {

return pre.concat(cur)

}, [])

console.log(result) // [1, 2, 3, 4, 5, 6, 7, 8, 9]

处理多维数组扁平化

要点：递归，判断是否是数组进行递归合并数组
入参：[[1,[2,3]],[[4,5,[6,[]]],[7,[8],9]]]
出参：[1, 2, 3, 4, 5,6, 7, 8, 9]
其他：arr3.flat(Infinity)，递归循环

let arr3 = [[1, [2, 3]], [[4, 5, [6, []]], [7, [8], 9]]]

const fn = (arr) => {

return arr.reduce((pre, cur) => {

return pre.concat(Array.isArray(cur) ? fn(cur) : cur)

}, [])

}

console.log(fn(arr3))// [1, 2, 3, 4, 5,6, 7, 8, 9]

数组去重

要点 indexOf，找到就不等于 -1 就为true，没有找到就== -1 就为 false ，走下面的push
入参：[1, 2, 3, 45, 6, 12, 3, 4, 12, 3, 1, 3, 2]
出参：[1, 2, 3, 45,6, 12, 4]

let arr4 = [1, 2, 3, 45, 6, 12, 3, 4, 12, 3, 1, 3, 2]

var result = arr4.reduce((pre, cur) => {

// !pre.includes(cur) && pre.push(cur)

pre.indexOf(cur) !== -1 || pre.push(cur)

return pre

}, [])

console.log(result) // [1, 2, 3, 45,6, 12, 4]

取出数组中最大值，最小值

入参：[1, 2, 3, 45, 6, 12, 3, 4, 12, 3, 1, 3, 2]
出参：最大值：45，最小值：1

let arr5 = [1, 2, 3, 45, 6, 12, 3, 4, 12, 3, 1, 3, 2]

var resultMax = arr5.reduce((pre, cur) => {

return pre > cur ? pre : cur

})

console.log(resultMax) // 45

var resultMin = arr5.reduce((pre, cur) => {

return pre < cur ? pre : cur

})

console.log(resultMin) // 1

得到下面数字每次出现的次数

要点：利用对象的key 去重，给value加加
value = 第一进来 pre[cur]对象没key就为空就会默认是 0 ，如果pre[cur]有key 就会取到key对应的value
入参：[1, 2, 3, 45, 6, 12, 3, 4, 12, 3, 1, 3, 2] * 出参：{ '1': 2, '2': 2, '3': 4, '4': 1, '6': 1, '12': 2, '45': 1 }

let arr6 = [1, 2, 3, 45, 6, 12, 3, 4, 12, 3, 1, 3, 2]

var result = arr6.reduce((pre, cur) => {

let value = pre[cur] || 0

pre[cur] = ++value

return pre

}, {})

console.log(result)

数组，根据name去重

入参：[{name: '小杜'},{name: '小杜'},{name: '李四'},{name: '王五'},{name: '王五'},{name: '小青'},{name: '小青'},{name: '桃子'},{name: '小刘'}];
出参：[{ name: '小杜' }, { name: '李四' }, { name: '王五' }, { name: '小青' }, { name: '桃子' }, { name: '小刘' }]

let arr7 = [

{name: '小杜'},

{name: '小杜'},

{name: '李四'},

{name: '王五'},

{name: '王五'},

{name: '小青'},

{name: '小青'},

{name: '桃子'},

{name: '小刘'}

];

var result = arr7.reduce((pre, cur) => {

pre.includes(cur.name) || pre.push(cur.name)

return pre

}, [])

console.log(result) // [ '小杜', '李四', '王五', '小青', '桃子', '小刘' ]

var result = arr7.reduce((pre, cur) => {

if (!pre.names.includes(cur.name)) {

pre.names.push(cur.name)

pre.unique.push(cur)

}

return pre

}, {names: [], unique: []})

console.log(result)

// {names: [ '小杜', '李四', '王五', '小青', '桃子', '小刘' ],

// unique: [{ name: '小杜' }, { name: '李四' }, { name: '王五' }, { name: '小青' }, { name: '桃子' }, { name: '小刘' }]}

对数组根据名称首字母分类

入参：[{ name: 'Bob' },{ name: 'Ben' },{ name: 'Cole' },{ name: 'Mary' },{ name: 'Travis' }]
出参：{ B: [ 'Bob', 'Ben' ], C: [ 'Cole' ], M: [ 'Mary' ], T: [ 'Travis' ] }

let arr8 = [

{name: 'Bob'},

{name: 'Ben'},

{name: 'Cole'},

{name: 'Mary'},

{name: 'Travis'}

]

var result = arr8.reduce((pre, cur) => {

let n = cur.name[0]

// 如果 pre 为空就要赋值一个数组，方便插入下一个name

if(!pre[n]) pre[n] = []

pre[n].push(cur.name)

return pre

}, {})

console.log(result) // { B: [ 'Bob', 'Ben' ], C: [ 'Cole' ], M: [ 'Mary' ], T: [ 'Travis' ] }