数组-reduce()方法

reduce()是接受一个函数作为累加器，数组中每一个值从左到右计算成一个值

语法：

arr.reduce(callback,[initialValuce])

callback//回调有四个参数

1.previousValue //上一次调用返回的值或者是提供的初始值（initialValue）
2.currentValue //数组当前被处理的元素
3.index//当前元素的索引值
4.array//调用的数组

initialValue //作为第一次调用callback的初始参数

initialValue解析

例子1.

var arr= [1,2,3,4];
var sum=arr.reduce((prev,cur,index,arr)=>{
      console.log(prev,cur,index)
       return prev+cur
})
    console.log(arr,sum)

打印结果

1  2  1
3  3  2
6  4  3
[1, 2, 3, 4] 10

总结：index是从1开始，数组长度是4，循环3次，第一次prev的值是数组的第一个值

例子2.

var arr= [1,2,3,4];
var sum=arr.reduce((prev,cur,index,arr)=>{
      console.log(prev,cur,index,arr)
      return prev+cur
},0)
    console.log(arr,sum)

打印结果

0 1 0
1 2 1 
3 3 2
6 4 3
[1, 2, 3, 4] 10

 总结：initialValue传值的话，索引是从0开始，循环4次

如果数组是空的话，initialValue没有传值的话会报错，但是如果传值的话就不会报错，所以一搬传值比较保险

var arr = []
var sum=arr1.reduce((prev,cur,index,arr)=>{
      console.log("1.",prev,cur,index,arr) 
      return prev+cur
})
   //报错  Reduce of empty array with no initial value
var sum=arr1.reduce((prev,cur,index,arr)=>{
      console.log(prev,cur,index,arr) 
      return prev+cur
},0)
      console.log(arr1,sum) //[] 0  不会报错

用reduce计算求和、求积

var arr = [1,2,3,4,5]
var sum=arr.reduce((x,y)=>x+y)
var mul=arr.reduce((x,y)=>x*y)
console.log(sum) //15
console.log(mul) //120
var mul1=arr.reduce((x,y)=>{
    return x*y
},1)
console.log(mul1) //120

计算数组中每个元素出现的次数

let arr =['张三','张三','李四','李四','王二']
let arrnum=arr.reduce((prev,cur)=>{
    console.log(prev,cur)
    if(cur in prev){
        prev[cur]++
    }else{
       prev[cur]=1 
    }
    return prev
},{})
console.log(arrnum)

结果

{} "张三"
{张三: 1} "张三"
{张三: 2} "李四"
{张三: 2, 李四: 1} "李四"
{张三: 2, 李四: 2} "王二"
{张三: 2, 李四: 2, 王二: 1}

if in

let obj = {
    name:'张三'
}
if('name' in obj){
    console.log('obj对象中包含name属性')
}else{
    console.log('obj对象中没有name属性')
}
//结果  obj对象中包含name属性

if in 判断对象是否包含某个属性

去重

let arr = [1,2,3,4,4,1,3]

let newArr = arr.reduce((pre,cur)=>{

    if(!pre.includes(cur)){ //判断pre是否包含cur

      return pre.concat(cur) //不包含就添加一个

    }else{

      return pre //包含就直接返回上一次执行的结果

    }

},[])

console.log(newArr);// [1, 2, 3, 4]

 

 

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

let newarr = arr.reduce((pre,cur)=>{

    pre.indexOf(cur) === -1 && pre.push(cur)

    return pre

},[])

console.log(newarr)// [1, 2, 3, 4, 5]

 

let arr = [1,2,3,4,4,1,3,5,5]
let newarr = arr.reduce((pre,cur)=>pre.includes(cur)?pre:[...pre,cur],[])
console.log(newarr) //[1, 2, 3, 4, 5]

二维转成一维

let arr = [[6,7],[4,5],[1,2,3]]
let newarr = arr.reduce((pre,cur)=>pre.concat(cur),[])
console.log(newarr) //[6, 7, 4, 5, 1, 2, 3]

多维转成一维

let arr = [[1,2,3],[4,5,6],[[7,8,9],10],[[11],[12],[13]]]
const newarr = function(arr){
    return arr.reduce((pre,cur)=>pre.concat(Array.isArray(cur)?newarr(cur):cur),[])
}
console.log(newarr(arr)) //[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]

对象里的属性求和

let arr = [
    {
        name:'张三',
        num:80
    },
    {
        name:'张三',
        num:140
    },
    {
        name:'张三',
        num:50
    },
    {
        name:'张三',
        num:60
    },
]
let newarr = arr.reduce((pre,cur)=>pre+cur.num,0)
console.log(newarr) //330

reduceRight()方法就是从右到左