定义
策略模式：定义一系列的算法，把它们一个个封装起来，并且使它们可以相互替换。
实现一个简单的策略模式
举一个例子来说明，很多公司每个月都绩效考核，考核完后还要发放绩效奖金，例如绩效为 S 的绩效奖金有0.2倍工资，绩效为 A 的绩效奖金有0.1倍工资，绩效为 B 的绩效奖金是 0 倍工资，绩效为 C 的绩效奖金是 -0.1 倍工资。假设人事部要求我们提供一段代码，来方便他们计算员工的每个月的绩效奖金。
cosnt calculatebonus = (level, salary) =>{
if (level === 'S') {
return salary * 0.2;
}
if (level === 'A') {
return salary * 0.1;
}
if (level === 'B') {
return salary * 0;
}
if (level === 'C') {
return salary * -0.1;
}
};
calculatebonus('S', 20000); // 输出：4000
calculatebonus('A', 6000); // 输出：600
上述代码十分简单实现人事部的需求，但是存在着显而易见的缺点。
calculatebonus函数比较庞大，包含了很多if-else语句，这些语句需要覆盖所有的逻辑 分支。calculatebonus函数可扩展性差，如果增加了一种新的绩效等级 D，或者想把绩效 C 的奖金 系数改为 0，那我们必须深入calculatebonus函数的内部实现，这是违反开放-封闭原则的。- 算法的复用性差，如果在其它地方需要重用这些计算绩效奖金的算法呢？难道用复制黏贴拷贝过去。
用策略模式就可与很好的解决上述的缺点。因此，我们需要重构这段代码。
策略模式指的是定义一系列的算法，把它们一个个封装起来，将算法的使用与算法的实现分离开来。将不变的部分和变化的部分隔开是每个设计模式的主题，策略模式也不例外。
一个基于策略模式的程序至少由两部分组成。第一个部分是一组策略类，策略类封装了具体的算法，并负责具体的计算过程。第二个部分是环境类，环境类接受客户的请求，随后把请求委托给某一个策略类。要做到这点，说明环境类中要维持对某个策略对象的引用。
那么第一步先把计算绩效奖金的算法封装出来，做出一个个策略类。
class LevelS {
calculate(salary) {
return salary * 0.2;
}
}
class levelA {
calculate(salary) {
return salary * 0.1;
}
}
class levelB {
calculate(salary) {
return salary * 0;
}
}
class levelC {
calculate(salary) {
return salary * -0.1;
}
}
然后创建一个环境类（计算绩效工资的类Bonus）
class Bonus {
constructor(...arguments) {
this.salary = null;//工资
this.strategy = null;//计算绩效工资的策略对象
}
setSalary(salary) {
this.salary = salary; // 设置工资
}
setStrategy(strategy) {
this.strategy = strategy; // 设置计算绩效工资的策略对象
}
getBonus(){
return this.strategy.calculate(this.salary);//计算绩效工资
}
}
如何使用呢？再回顾一下策略模式的定义：“定义一系列的算法，把它们一个个封装起来，并且使它们可以相互替换”。再解释详细一点。定义一系列的算法，把它们各自封装成策略类，算法被封装在策略类内部的方法里。在客户对环境类发起请求的时候，环境类总是把请求委托某个策略类，调用策略类中的算法计算。
在上面的例子中，Bonus类就是环境类，客户对环境类发起请求就是实例化一个环境类。调用bonus.setStrategy来委托给某个策略类。
const bonus = new Bonus();
bonus.setSalary( 20000 );//设置工资
bonus.setStrategy( new LevelS() ); // 设置策略对象
console.log( bonus.getBonus() ); // 输出：4000
bonus.setSalary( 6000 );//设置工资
bonus.setStrategy( new LevelA() ); // 设置策略对象
console.log( bonus.getBonus() ); // 输出：600
