好久沒有更新了，最近學習的過程中一直在用聯想的思維來去看問題，javascript是一門非常靈活的語言，集合了好多語言的特性和多種編程模式，對于compose的實現，就有非常多的思路，每一種思路都有自己的特點，實現之后，有種殊途同歸的快感。下面就是我總結的實現compose函數的五種思路。

面向過程

函數組合（reduce）

函數交織（AOP編程）

Promise（sequence）

Generator（yield）

簡單回顧一下compose，compose就是執行一系列的任務（函數），比如有以下任務隊列，

let tasks = [step1, step2, step3, step4]

每一個step都是一個步驟，按照步驟一步一步的執行到結尾，這就是一個compose
compose在函數式編程中是一個很重要的工具函數，在這里實現的compose有三點說明

第一個函數是多元的（接受多個參數），后面的函數都是單元的（接受一個參數）

執行順序的自右向左的

所有函數的執行都是同步的（異步的后面文章會講到）

還是用一個例子來說，比如有以下幾個函數

let init = (...args) => args.reduce((ele1, ele2) => ele1 + ele2, 0)
let step2 = (val) => val + 2
let step3 = (val) => val + 3
let step4 = (val) => val + 4

這幾個函數組成一個任務隊列

steps = [step4, step3, step2, init]

使用compose組合這個隊列并執行

let composeFunc = compose(...steps)

console.log(composeFunc(1, 2, 3))

執行過程
6 -> 6 + 2 = 8 -> 8 + 3 = 11 -> 11 + 4 = 15
所以流程就是從init自右到左依次執行，下一個任務的參數是上一個任務的返回結果，并且任務都是同步的，這樣就能保證任務可以按照有序的方向和有序的時間執行。

所有思路的執行過程都是上面的例子，以下只講compose實現

這個思路就是使用遞歸的過程思想，不斷的檢測隊列中是否還有任務，如果有任務就執行，并把執行結果往后傳遞，這里是一個局部的思維，無法預知任務何時結束。直觀上最容易結束和理解。

const compose = function(...args) {
  let length = args.length
  let count = length - 1
  let result
  return function f1 (...arg1) {
    result = args[count].apply(this, arg1)
    if (count <= 0) {
      count = length - 1
      return result
    }
    count--
    return f1.call(null, result)
  }
}

代碼地址

這個思路是一種函數組合的思想，將函數兩兩組合，不斷的生成新的函數，生成的新函數挾裹了函數執行的邏輯信息，然后再兩兩組合，不斷的傳遞下去，這種思路可以提前遍歷所有任務，將任務組合成一個可以展開的組合結構，最后執行的時候就像推導多米諾骨牌一樣。

函數的組合過程

f1 = (...arg) => step2.call(null, init.apply(null, arg))
f2 = (...arg) => step3.call(null, f1.apply(null, arg))
f3 = (...arg) => step4.call(null, f2.apply(null, arg))

compose實現

const _pipe = (f, g) => (...arg) => g.call(null, f.apply(null, arg))
const compose = (...args) => args.reverse().reduce(_pipe, args.shift())

代碼地址

這個實現的靈感來自javascript設計模式中的高階函數，因為compose的任務在本質上就是函數執行，再加上順序，所以可以把實現順序執行放到函數本身，對函數的原型進行方法的綁定。方法的作用對象是函數，面向對象封裝的數據，面向函數封裝的是函數的行為。

需要對函數綁定兩個行為 before 和 after，before執行函數多元部分（啟動），after執行函數單元部分

Function.prototype.before = function(fn) {
  const self = this
  return function(...args) {
    let result = fn.apply(null, args)
    return self.call(null, result)
  }
}

Function.prototype.after = function(fn) {
  const self = this
  return function(...args) {
    let result = self.apply(null, args)
    return fn.call(null, result)
  }
}

這里對函數進行方法的綁定，返回的是帶著函數執行的規則的另外一個函數，在這里是次序的排列規則，對返回的函數依然可以進行鏈式調用。
compose實現

const compose = function(...args) {
  let before = args.pop()
  let start = args.pop()
  if (args.length) {
    return args.reduce(function(f1, f2) {
      return f1.after(f2)
    }, start.before(before))
  }
  return start.before(before)
}

函數執行過程

step2.before(init).after(step3).after(step4)
fn3.after(step4)
fn3 = fn2.after(step3)
fn2 = fn1.before(step1)
fn1 = init -> step2 -> step3 -> step4

代碼地址

ES6引入了Promise，Promise可以指定一個sequence，來規定一個執行then的過程，then函數會等到執行完成后，再執行下一個then的處理。啟動sequence可以使用
Promise.resolve()這個函數。構建sequence可以使用reduce
compose實現

const compose = function(...args) {
  let init = args.pop()
  return function(...arg) {
    return args.reverse().reduce(function(sequence, func) {
      return sequence.then(function(result) {
        return func.call(null, result)
      })
    }, Promise.resolve(init.apply(null, arg)))
  }
}

代碼地址

Generator主要使用yield來構建協程，采用中斷，處理，再中斷的流程。可以事先規定好協程的執行順序，然后再下次處理的時候進行參數（結果）交接，有一點要注意的是，由于執行的第一個next是不能傳遞參數的，所以第一個函數的執行需要手動調用，再空耗一個next，后面的就可以同步執行了。
generator構建

function* iterateSteps(steps) {
  let n
  for (let i = 0; i < steps.length; i++) {
    if (n) {
      n = yield steps[i].call(null, n)
    } else {
      n = yield
    }
  }
}

compose實現

const compose = function(...steps) {
  let g = iterateSteps(steps)
  return function(...args) {
    let val = steps.pop().apply(null, args)
    // 這里是第一個值
    console.log(val)
    // 因為無法傳參數 所以無所謂執行 就是空耗一個yield
    g.next()
    return steps.reverse.reduce((val, val1) => g.next(val).value, val)
  }
}

代碼地址

github地址

github里面針對每一種實現包含了完成的demo案例，就在test.js里面，以上就是實現同步compose的五種思路，每一種思路的出發點都不一樣，但是實現的目的都是一樣的，可以看出javascript是非常靈活的,借助es6的Promise和Generator也可以很優雅的實現。后面會介紹compose的異步實現，在函數式編程來看，異步的本質應該就是Monad。