js设计模式4-策略模式

策略模式是指定义一系列的算法，把它们一个个封装起来，并且使它们可以相互替换。

策略模式通俗点就是业务选择逻辑的优化封装，if/else,switch...case的高级应用

function calculatorBonus (level, salary) {
  if (level == 'A') {
    return salary * 4
  }
  if (level == 'B') {
    return salary * 2
  }
  if (level == 'C') {
    return salary * 1
  }
  if (level == 'D') {
    return salary * -1
  }
}



const p1 = calculatorBonus('A', 20000)
const p2 = calculatorBonus('B', 12000)
console.log(p1)
console.log(p2)

 

上面的是普通的if...else计算，不同的情况，就是在函数里面不断的罗列所有的情况，现在是比较简单的业务，可以接收这样的代码，但是业务大了后，这样就会显得很low，数不清的if...else充斥着。

于是我们再改进这个程序

var performanceA = function (salary) {
  return salary * 4
}


var performanceB = function (salary) {
  return salary * 2
}
var performanceC = function (salary) {
  return salary * 1
}

var calculatorBonus = function (level, salary) {
  if (level == 'A') {
    return performanceA(salary)
  }
  if (level == 'B') {
    return performanceB(salary)
  }
  if (level == 'C') {
    return performanceC(salary)
  }
}


const p1 = calculatorBonus('A', 20000)
const p2 = calculatorBonus('B', 12000)
console.log(p1)
console.log(p2)

很失望，是不是！我就是很失望，有改进，但是还是没有达到我们的预期。

所以，我们继续改善。。 上面的方法给我们了一个提示，就是策略模式，执行的方法都同一个方法

//首先定义策略类

var performanceA = function () { }

performanceA.prototype.calculator = function (salary) {
  return salary * 4
}


var performanceB = function () { }
performanceB.prototype.calculator = function (salary) {
  return salary * 2
}

var performanceC = function () { }
performanceC.prototype.calculator = function (salary) {
  return salary * 2
}

//奖金类

var Bonus = function () {
  this.salary = null;
  this.strategy = null;
}

Bonus.prototype.setSalary = function (salary) {
  this.salary = salary;
}

Bonus.prototype.setStrategy = function (strategy) {
  this.strategy = strategy
}

//闭合整个业务链条
Bonus.prototype.getBonus = function () {
  return this.strategy.calculator(this.salary)
}



//使用方法
var b1 = new Bonus()
b1.setSalary(40000);
b1.setStrategy(new performanceA())
console.log(b1.getBonus())
b1.setSalary(40000);
b1.setStrategy(new performanceB())
console.log(b1.getBonus())

上面的是传统的面向对象的策略模式，所以更简单和直接的方法，我们可以如下的操作

var strategy = {
  "A": function (salary) {
    return salary * 4
  },
  "B": function (salary) {
    return salary * 2
  },
  "C": function (salary) {
    return salary * 1
  }
}


var calculatorBonus = function (level, salary) {
  return strategy[level](salary)
}

console.log(calculatorBonus('A', 30000))
console.log(calculatorBonus('B', 30000))

总结:

通过使用策略模式重构代码，消除了原程序中大片的条件分支语句。所有跟计算奖金有关的逻辑不再放在Context 中，而是分布在各个策略对象中。Context并没有计算奖金的能力，而是把这个职责委托给了某个策略对象。每个策略对象负责的算法已被各自封装在对象内部。当对这些策略对象发出“计算奖金”的请求时，它们会返回各自不同的计算结果，这正是对象多态性的体现，也是“它们可以相互替换”的目的。替换 Context 中当前保存的策略对象，便能执行不同的算法来得到想要的结果。

参考资料:https://www.cnblogs.com/xiaohuochai/p/8029651.html