reduce详情

定义和用法

reduce() 方法将数组缩减为单个值。
reduce() 方法为数组的每个值（从左到右）执行提供的函数。
函数的返回值存储在累加器中（结果/总计）。
注释：
1、对于没有值得数组元素，不执行reduce()方法。
2、reduce()方法不会改变原始数组。
语法：

array.reduce(function(prev, cur, index , arr), init)

参数值：

//prev  必需；init，或上一次的计算结果的返回值（用的较多）。
//cur   必需：数组中正在处理的元素。若指定了初始值，则值则为数组索引为 0 的元素，否则为 1。
//index 可选：数组中正在处理的元素的索引。若指定了初始值，则起始索引为 0，否则为 1。
//arr   可选：被遍历的对象数组。

//init  可选：此参数作为第一次调用函数时参数 prev 的值,
            //若指定了初始值 init，则 cur 则将使用数组第一个元素,
            //否则 perv 将使用数组的第一个元素，而 cur 将使用数组第二个元素.

1、解析：

如果没有设置init初始值

btn(){
                let array=[1,2,3,4,5,6]
                let init = 1
                this.Array.reduce((prev,cur,index,arr)=>{
                    console.log(prev,cur,index);
                    return prev + cur
                })
            },
            // reduce.html:41    1 2 1         
            // reduce.html:41    3 3 2
            // reduce.html:41    6 4 3
            // reduce.html:41    10 5 4
            // reduce.html:41    15 6 5

设置了init初始值

  btn(){
                let array=[1,2,3,4,5,6]
                let init = 1
                this.Array.reduce((prev,cur,index,arr)=>{
                    console.log(prev,cur,index);
                    return prev + cur
                },0)
            },
            // reduce.html:34    0 1 0
            // reduce.html:34    1 2 1
            // reduce.html:34    3 3 2
            // reduce.html:34    6 4 3
            // reduce.html:34    10 5 4
            // reduce.html:34    15 6 5

结论：如果没有提供init初始值，reduce 会从索引1的地方开始执行 callback 方法，跳过第一个索引。如果提供init，从索引0开始。

2、计算总和

 //计算总和
    sum(){
          // let init = 1
         	let array = [1,2,3,4,5]
            let Sum=array.reduce((prev,cur,index,arr)=>{
                  return prev + cur
             })
           	console.log('Sum:'+Sum);  //Sum: 15
         	},
             

3、计算乘积

// 计算乘积
product(){
    let array = [1,2,3,4,5]
    let Sum = array.reduce((prev,cur,index,arr)=>{
             console.log(prev);  //1  2  6  24
             return prev*cur
        },)
    console.log(Sum);         //Sum:  120
    },

4、数组去重(★)

 arrDedup(){
       let array = [1,2,2,3,3,4,4,5,5]
       let Sum = array.reduce((prev,cur,index,arr)=>{
       //includes:通过元素看这个数组中是否只有这个元素，返回布尔类型值
       //concat:连接字符串
       if(!prev.includes(cur)){
                return prev.concat(cur)
       }else{
           return prev
          }
       },[])
       console.log(Sum);  //[1, 2, 3, 4, 5]
       },

5、二维数组转一维数组

//二维数组转一维数组
 transform(){
 //concat:连接字符串
 let array=[[1,2],[3,4],[5,6]]
 let Sum = array.reduce((prev,cur,index,arr)=>{
            return prev.concat(cur)
       },[])
  console.log(Sum);  //[1, 2, 3, 4, 5, 6]
  },

6、多维数组转一维

//多维数组转一维
transformArr(){
let array = [[1,2],[3,4],[4,[5,6,[7,8]]]]
let Sum = function(array){
          return array.reduce((prev,cur,index,arr)=>{
          //console.log(Array.isArray(cur));
          //重点
          return prev.concat(Array.isArray(cur)?Sum(cur):(cur))
          },[])
          }
         //Sum(array)
       	console.log(Sum(array));  //[1, 2, 3, 4, 4, 5, 6, 7, 8]     

7、对象里的属性求和

 // 对象里的属性求和
 objSum(){
      let result  = [
            {
                subJect:'math',
                score:10,
              },
              {
                subJect:'chinese',
                score:20,
               },
               {
                subJect:'english',
                score:30,
                },
              ]
       // prev:上一次的计算结果的返回值。初始值为init 或者是数组中的第一个值
       let Sum = result.reduce((prev,cur,index,arr)=>{
       // console.log(prev); //0  10  30
                 return cur.score + prev  //第一次返回  10+0=10  第二次返回  20+10=30  第三次返回  30+30=60
            },0)
            console.log(Sum);
           },