reduce的一些用法总结

接收参数

reduce接收两个参数，一个是执行函数，一个是初始值

执行函数中的参数有pre,cur,curIndex,arr

    //pre:前一次调用回调的返回值
    //cur正在处理的元素
    //curIndex正在处理的元素的索引
    //arr,正在遍历的对象

arr.reduce(function(pre,cur,curIndex,arr){},initialValue)

使用reduce实现sum

arr.reduce((pre,cur)=>pre+cur,0);

使用reduce将二维数组变成一维

function flatten(arr){
  return arr.reduce((pre,cur)=>{
    return pre.concat(cur);
},[])
}

多维数组扁平化

//多维数组扁平化
function superFlatten(arr) {
  return arr.reduce((pre, cur) => {
    return cur instanceof Array ? pre.concat(superFlatten(cur)) : pre.concat(cur)
  },[])
}

另外插播一个数组扁平化的其他实现

es5递归

function myFlatten(arr) {
  let res = []
  //遍历
  for (let i = 0; i < arr.length; i++) {
    arr[i] instanceof Array ? res = res.concat(myFlatten(arr[i])) : res.push(arr[i])

  }
  return res;
}

some

        function myFlatten(arr) {
            while (arr.some(item => item instanceof Array)) {
                arr = [].concat(...arr);
            }
            return arr;
        }

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

let res = arr.reduce((obj,key)=>{
  if(obj[key]){
    obj[key]++;
  }else{
    obj[key] = 1
  }
  return obj;
},{})

使用reduce实现map方法

实现思路

1. 在数组的原型对象中定义myMap方法，接收参数为fn和上下文对象thisArg
2. 判断有没有传入thisArg
3. 定义一个[]，存放map的返回结果
4. 执行reduce方法，为数组中每一个元素执行fn并且添加到[]中
5. 返回结果 代码实现

//使用reduce实现map方法
Array.prototype.myMap = function(fn,thisArg){
  //上下文对象
  thisArg = thisArg || [];
  //一个存储res的数组
  let res = []
  //reduce
  this.reduce((pre,cur,index,arr)=>{
    res.push(fn.call(thisArg,cur,index,arr))
  },[])
  return res;

}

使用js原生实现reduce方法

实现思路

1. 在数组原型中定义reduce方法，接收两个参数，一个是fn，一个是初始值initialValue（可以没有）
2. 分别获取到数组，数组的长度
3. 定义一个开始计算的值start，如果有初始值就从初始值开始，如果没有初始值就从数组中第一个开始
4. 遍历，不断更新start
5. 返回计算结果start

        Array.prototype.reduce2 = function (fn, initialValue) {
            const O = Object(this);
            const len = O.length >>> 0;
            let k = 0, start;
            //如果有初始值
            if (arguments.length > 1) {
                start = initialValue
            } else {
                //没有初始值，start为第一个，并且从下一个开始执行
                start = O[k];
                k++;
            }

            while (k < len) {
                if (k in O) {
                //不断更新start
                    start = fn(start, O[k], k, O);
                }
                k++
            }
            return start;
        }