读后感 - 数组reduce

看到数组reduce想到了redux的middleware的实现，也想到了串行执行函数的面试问题。今天干好可以整理下这个概念，当是自己熟悉下

let listFun = [
  function (next) {
    console.log(1);
    return function(arg) {
      return next(arg)
    }
  },
  function (next) {
    console.log(2);
    return function(arg) {
      return next(arg)
    }
  },
  function (next) {
    console.log(3);
    return function(arg) {
      return next(arg)
    }
  },
];

let totalFun = listFun.reduce((acc,current) => {
  return function(args) {
    return acc(current(args))
  }
})

// // reduce，第一次执行返回1和2，第二次遍历，叠加器是一个undefined，current是一个返回3的函数
// // 让叠加器成为一个函数，改造listFun内部函数都返回一个匿名函数
// // 第一次遍历：函数2执行后将内部函数作为参数给到函数1
// // 第二次遍历：函数3执行后将内部函数作为函数1内部函数的参数，并返回函数函数3的内部函数
// // 这个关系比较混乱了，没有形成函数串联
// // 改造reduce的内部，每次返回一个匿名函数,最后一步拿到的是一个匿名函数
// /**
//  * 第一次遍历返回一个匿名函数 包裹着 [1(2(...))]
//  * 第二次遍历返回一个新的匿名函数 包裹着 [ [1(2(...))](3(...)) ]
//  * 最后返回的是第二次遍历返回新的匿名函数
//  * 
//  * 第一次执行最后返回的匿名函数，middlewares按照从右到左的顺序，最后一步返回第一个middleware的匿名函数
//  * 第二次执行的时候传递一个参数保证整个middlewares拿到的都是相同的store
//  * 这就形成了一个middleware的串联和数据共享（函数具有延迟执行的特性）
//  */
let dispatch = function(arg){
  return arg
}

let fun1anony = totalFun(dispatch)

fun1anony({name:'dispatch'})

redux的middleware就是通过reduce的方式把函数串行到一起，中间穿插着匿名函数。

串行发送请求，一个接一个来，也是面试中喜欢问的问题，写法多种，async await

let list = [
    function() {
        return Promise.resolve(1)
    },
    function() {
        return Promise.resolve(2)
    },
    function() {
        return Promise.resolve(3)
    },
    function() {
        return Promise.resolve(4)
    },
    function() {
        return Promise.resolve(5)
    }
]

list.reduce((chain,item) => {
    return chain.then(res => {
        return item()
    }).then(res => {
        console.log(res)
    })
}, Promise.resolve(0))
// 1,2,3,4,5