定义:定义一系列的算法,把它们一个个封装起来,并且使它们可以相互替换。
一个策略模式的实现至少包含两部分:
1.策略类,封装了具体的算法,负责具体计算过程。
2.环境类,接收客户的请求,将请求委托给某个策略类处理。
比如下面的场景:一个公司需要计算年终奖,不同绩效的员工年终奖计算方式不同,绩效S的员工,年终奖为4倍工资,绩效A年终奖为3倍工资,绩效B年终奖为2倍工资。代码实现:
function calcBonus (performanceLebel, salary) {
if (performanceLebel === 'S') {
return salary * 4
}
if (performanceLebel === 'A') {
return salary * 3
}
if (performanceLebel === 'B') {
return salary * 2
}
}
很简单就完成了,但是很明显这样的代码缺点不少:
- 包含很多的if-else语句,需要覆盖所有的逻辑,当逻辑复杂时,函数体变得十分臃肿庞大
- 后续迭代麻烦,需求更改时,需要直接修改
calcBonus
函数 - 复用度不好,计算逻辑堆叠在了
calcBonus
函数里,当其他地方想要复用一部分计算逻辑时,只有复制粘贴
再看看策略模式的实现,首先找到策略类和环境类:
// 具体的奖金计算过程抽离在了策略类的方法中,复用方便
const performanceS = function () {}
performanceS.prototype.calculate = function (salary) {
return salary * 4
}
const performanceA = function () {}
performanceA.prototype.calculate = function (salary) {
return salary * 3
}
const performanceB = function () {}
performanceB.prototype.calculate = function (salary) {
return salary * 2
}
// 环境类,转发请求
const 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.calculate( this.salary )
}
const bonus = new Bonus()
bonus.setSalary(1000)
bonus.setStrategy( new performanceS() ) // 设置策略类
bonus.getBonus() // 4000
这是典型的面向对象做法,如果是要实现策略类,在js里,普通的函数就可以完成了:
const stragegies = { // 增加新的计算方式或者需求变动,修改stragegies对象即可
"S": function (salary) {
return salary * 4
},
"A": function (salary) {
return salary * 3
},
"B": function (salary) {
return salary * 2
},
}
function calcBounus(lebel, salary) {
return strategies[ level ](salary)
}
calcBonus('S', 1000) // 4000
calcBonus('A', 1000) // 3000
策略模式还有一个常用场景,就是表单验证。