js 数组 reduce reduceRight

reduce

reduce 为数组中的每一个元素从左到右依次执行回调函数

reduce有两个参数 callBack ,initVal

callBack有四个参数

1. prev 上一次调用的返回值或者提供的初始值
2. curr 当前项
3. index 当前项的索引
4. arr 调用reduce的数组

initVal

      reduce 调用的初始值

reduce求和 没有初始值

let list = [1,2,3,4,5,6,7]
let sum = list.reduce((prev,curr,index,arr)=>{
   return prev+curr
})
console.log(sum)//28

reduce求和 有初始值

let list = [1,2,3,4,5,6,7]
let sum = list.reduce((prev,curr,index,arr)=>{
   return prev+curr
},100)
console.log(sum)//128

reduce 求乘积

let list = [1,2,3,4,5,6,7]
let sum1 = list.reduce((x,y)=>{
    return  x*y
})
console.log(sum1)

reduce 求数组中每个元素出现的次数

let name = ["song", "jia", "feng", "song", "song", "jia", "feng", "song", "hefing"]
let nameNums = name.reduce((pre, cur) => {
    if (pre[cur]) {
        pre[cur]++
    } else {
        pre[cur] = 1
    }
    return pre
}, {})

console.log(nameNums)
//{ song: 4, jia: 2, feng: 2, hefing: 1 }
/* 
  reduce的初始值为 空对象
  一开始的时候 pre是空对象
  cur作为 pre对象的属性名 
  如果 pre[cur] 存在就 就让它的值加1 
  入果 pre[cur] 不存在就 让 它为 1
*/

reduce 数组去重

let arr = ["song", "jia", "feng", "song", "song", "jia", "feng", "song", "hefing"]
let newArr = arr.reduce((pre, cur) => {
    if (!pre.includes(cur)) {//如果 当前项cur在 pre中不存在就 把 当前项和pre concat拼接
        return pre = pre.concat(cur)
    } else {
        return pre  //入果 当前项 在 pre中存在就 不需要添加 直接将 pre 返回出去 进行下一次处理即可
    }
}, [])
console.log(newArr)

reduce 二维数组转一维数组

let arr = [
    [
        '1', '2', '3'
    ],
    [
        '4', '5', '6', '3'
    ], [
        '7', '8'
    ]
]
let newArr = arr.reduce((pre, cur) => {
    return pre.concat(cur)
}, [])
console.log(newArr)
/* 
[
  '1', '2', '3',
  '4', '5', '6',
  '3', '7', '8'
]
*/

reduce 多维数组转一维数组

let arr = [
    [
        '1', '2', '3',
        [
            "11", "22", "333", "44"
        ]
    ],
    [
        '4', '5', '6', '3',
        [
            "112", "222", "3332", "443"
        ]
    ], [
        '7', '8'
    ]
]

const newArr = function (arr) {
    return arr.reduce((pre, cur) => {
        return pre.concat(Array.isArray(cur) ? newArr(cur) : cur)
    }, [])
}
let result = newArr(arr)
console.log("result", result)
/* 
result [
  '1',   '2',    '3',
  '11',  '22',   '333',
  '44',  '4',    '5',
  '6',   '3',    '112',
  '222', '3332', '443',
  '7',   '8'
]
*/

reduce数组转对象

let list = [
    {
        id: '0',
        name: '小明'
    }, {
        id: '1',
        name: '小明'
    }, {
        id: '2',
        name: '小明'
    }, {
        id: '3',
        name: '小明'
    }, {
        id: '4',
        name: '小明'
    },
]

let result = list.reduce((pre,cur)=>{
    return {
        ...pre,[cur.id]:cur
    }
},{})

/* 
  初始值 是 {}
  没次将 之前的 pre对象 结构出来,然后 将 cur.id作为属性名 cur作为对象的属性值
*/
console.log("result",result)
/* 
result {
  '0': { id: '0', name: '小明' },
  '1': { id: '1', name: '小明' },
  '2': { id: '2', name: '小明' },
  '3': { id: '3', name: '小明' },
  '4': { id: '4', name: '小明' }
}
*/

总结

reduce的核心思想是将 这一次处理的结果值作为下一次的初始值，继续进行处理，知道处理完所有的数据，拿到一个结果值