例子

  1. 充值 500 （orderType = 1），100%（isPay 充值成功）中 100 的优惠券
  2. 充值 200 （orderType = 2），100%（isPay 充值成功）中 20 的优惠券
  3. 不充值（orderType = 3），根据优惠券的库（count）存来决定，有机会中 10 的优惠券
    1. var order = function(orderType, isPay, count) {
    2.  if(orderType === 1) {
    3.    // 充值 500
    4.  if(isPay) {
    5.    // 充值成功，100% 中奖
    6.      console.log("恭喜中奖 100 优惠券");
    7.  } else {
    8.      if(count > 0) {
    9.        console.log("恭喜中奖 10 优惠券");
    10.    } else {
    11.        console.log("很遗憾没有优惠券");
    12.    }
    13.  }
    14. } else if(orderType === 2) {
    15.    // 充值 200
    16.  if(isPay) {
    17.    // 充值成功，100% 中奖
    18.      console.log("恭喜中奖 20 优惠券");
    19.  } else {
    20.      if(count > 0) {
    21.        console.log("恭喜中奖 10 优惠券");
    22.    } else {
    23.        console.log("很遗憾没有优惠券");
    24.    }
    25.  }
    26. } else if(orderType === 3) {
    27.  if(count > 0) {
    28.    console.log("恭喜中奖 10 优惠券");
    29.  } else {
    30.    console.log("很遗憾没有优惠券");
    31.  } 
    32. } 
    33. }

    使用责任链模式进行优化

    把各种模式单独地抽离出来 ```javascript function order500(orderType, isPay, count) { if(orderType ==== 1 && isPay) { console.log(“恭喜中奖 100 优惠券”); } else { return “next”; } }

function order200(orderType, isPay, count) { if(orderType ==== 2 && isPay) { console.log(“恭喜中奖 20 优惠券”); } else { return “next”; } }

function orderNormal(orderType, isPay, count) { if(count > 0) { console.log(“恭喜中奖 10 优惠券”); } else { console.log(“很遗憾没有优惠券”); } }

  1. 通过一种方式把三种模式串成一条链条，也就是 Chain 函数：
  2. ```javascript
  3. var Chain = function(fn) {
  4.     this.fn = fn;
  5.   this.next = null;
  6. }
  8. Chain.prototype.setNext = function(nextChain) {
  9.     return (this.next = nextChain);
  10. }
  11. Chain.prototype.passRequest = function() {
  12.     var res = this.fn.apply(this, arguments);
  13.   if(res === "next") {
  14.       return this.next && this.next.passRequest.apply(this.next, arguments);
  15.   }
  17.   return res;
  18. }

使用先用 Chain 包装一下每一个模式的函数，并设置各自的 nextChain 来指定链条的顺序
使用 passRequest 来调用

  1. var chainOrder500 = new Chain(order500);
  2. var chainOrder200 = new Chain(order200);
  3. var chainOrderNormal = new Chain(orderNormal);
  5. chainOrder500.setNext(chainOrder200);
  6. chainOrder200.setNext(chainOrderNormal);
  8. chainOrder500.passRequest(1, true, 500);
  9. chainOrder500.passRequest(2, true, 500);
  10. chainOrder500.passRequest(3, true, 500);
  11. chainOrder500.passRequest(1, false, 500);
  12. chainOrder500.passRequest(1, false, 0);

责任链模式结合 AOP 来作优化

高阶函数应用：AOP 面向切片编程

不使用 Chain 的方式来传递函数，而通过 AOP 的 after

  1. Function.prototype.after = function(fn) {
  2.     var _this = this;
  3.   return function() {
  4.       var res = _this.apply(this, arguments);
  5.     if(res === 'next') {
  6.         return fn.apply(this, arguments);
  7.     }    
  8.     return res;
  9.   }
  10. }
  12. var order = order500.after(order200).after(orderNormal);
  14. order(1, true, 500);
  15. order(2, true, 500);
  16. order(3, true, 500);
  17. order(1, false, 500);
  18. order(1, false, 0);