责任链模式

责任链模式只能用于处理所有函数处理同一份参数的情况, 比如改造多个if else
函子模式,可以传递值,如对一个对象进行解析
currying化中,涉及到三个上下文: 载体函数self1,被执行函数self2,执行函数self3

function A(fn){
  let self1= this
  return function(){
       let self2 = fn
       let self3 = this
  }
}
   Function.prototype.before = function (fn) {
        var self = this
        // fn为当前方法, self为上个方法, 
        // 从左到右依次执行,应该是self.apply先执行
        // 从右到左逆执行, 应该是fn先执行
        return function () {
          var ret = fn.apply(this, arguments) 
          if (ret === 'prev') {
            return self.apply(this, arguments)
          }
          return ret
        }
      }
      Function.prototype.after = function (fn) {
        var self = this
        // fn为当前方法, self为上个方法, 
        // 从左到右依次执行,应该是self.apply先执行
        // 从右到左逆执行, 应该是fn先执行
        return function () {
          var ret = self.apply(this, arguments) 
         // ret不能用传递前后参数,只能用于控制是否执行下一步,  fn1和fn2可以传递参数,但fn2和fn3传递不了,只能借用外置对象来处理
          if (ret === 'next') {
            return   fn.apply(this, arguments) 
          }
          return ret
        }
      }  

    function A(type){
        if(type!="A"){
          return 'prev'
        }
        return 'nullA'
    }
    function B(type){
        if(type!="B"){
          return 'prev'
        }
        return 'nullB'
    }
    function C(type){
        if(type!="C"){
          return 'prev'
        }
        return 'nullC'
    }

    let order = A.before(B).before(C)('B')

    console.log(order)


    function A2(type){
        if(type!="A"){
          return 'next'
        }
        return 'nullA'
    }
    function B2(type){
        if(type!="B"){
          return 'next'
        }
        return 'nullB'
    }
    function C2(type){
        if(type!="C"){
          return 'next'
        }
        return 'nullC'
    }
    let order2 =A2.after(B2).after(C2)('C')
    console.log(order2)


  //异步函数的改写
  Function.prototype.after = function (fn) {
        var self = this
        // fn为当前方法, self为上个方法, 
        // 从左到右依次执行,应该是self.apply先执行
        // 从右到左逆执行, 应该是fn先执行
        return async function () {
          var ret =await self.apply(this, arguments)
          if (ret === 'next') {
            return await fn.apply(this, arguments)
          }
          return ret
        }
      }
      async function Fn1(param) {
        let res = await new Promise((re, rj) => {
          setTimeout(() => {
            let val = true
            console.log(param+'Fn1')
            
            re(val)
          }, 1000)
        })
         
        return res ? 'next' : false
      }
      async function Fn2(param) {
        let res = await new Promise((re, rj) => {
          setTimeout(() => {
            let val = true
            console.log(param+'Fn2')
            re(val)
          }, 1000)
        })
         
        return res ? 'next' : false
      }
      async function Fn3(param) {
        let res = await new Promise((re, rj) => {
          setTimeout(() => {
            let val = true
            console.log(param+'Fn3')
            re(val)
          }, 1000)
        })
         
        return res ? 'next' : false
      }


      console.log(Fn1.after(Fn2).after(Fn3)('test'))


// 函子写法
  function Container (val){
         this.value=val 
       }
         Container.prototype.map=async function(fn){ 
         return  Container.of(await fn(this.value))
       }    
       Container.of= function(val){
          return  new Container(val)
       }
  
      async function Fn1(param) {
        let res = await new Promise((re, rj) => {
          setTimeout(() => {
            let val = true
            console.log(param+'Fn1')
            re(val)
          }, 1000)
        })
         
        return res ? 'next' : false
      }
      async function Fn2(param) {
        let res = await new Promise((re, rj) => {
          setTimeout(() => {
            let val = true
            console.log(param+'Fn2')
            re(val)
          }, 1000)
        })
         
        return res ? 'next' : false
      }
      async function Fn3(param) {
        let res = await new Promise((re, rj) => {
          setTimeout(() => {
            let val = true
            console.log(param+'Fn3')
            re(val)
          }, 1000)
        })
         
        return res ? 'next' : false
      }
    
       let obj = Container.of('test')
       let res1 = await obj.map(Fn1)
       let res2 = await res1.map(Fn2)
       let res3 = await res2.map(Fn3)