策略模式：使用策略模式计算奖金

蜗蜗
356 阅读5分钟

在现实中，很多时候也有多种途径到达同一个目的地。比如我们要去某个地方旅游，可以根据具体的实际情况来选择出行的线路。

  • 如果没有时间但是不在乎钱，可以选择坐飞机。
  • 如果没有钱，可以选择坐大巴或者火车。
  • 如果再穷一点，可以选择骑自行车。

在程序设计中，我们也常常遇到类似的情况，要实现某一个功能有多种方案可以选择。比如一个压缩文件的程序，既可以选择zip算法，也可以选择gzip算法。

这些算法灵活多样，而且可以随意互相替换。这种解决方案就是策略模式。

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

使用策略模式计算奖金

很多公司的年终奖是根据员工的工资基数和年底绩效情况来发放的。例如，绩效为S的人年终奖有4倍工资，绩效为A的人年终奖有3倍工资，而绩效为B的人年终奖是2倍工资。假设财务部要求我们提供一段代码，来方便他们计算员工的年终奖。

1．最初的代码实现

我们可以编写一个名为calculateBonus的函数来计算每个人的奖金数额。很显然，calculateBonus函数要正确工作，就需要接收两个参数：员工的工资数额和他的绩效考核等级。代码如下：

var calculateBonus = function( performanceLevel, salary ){

  if ( performanceLevel === 'S' ){
    return salary * 4;
  }

  if ( performanceLevel === 'A' ){
    return salary * 3;
  }

  if ( performanceLevel === 'B' ){
    return salary * 2;
  }

};

calculateBonus( 'B', 20000  );      // 输出：40000
calculateBonus( 'S', 6000 );      // 输出：24000

可以发现，这段代码十分简单，但是存在着显而易见的缺点。

  • calculateBonus函数比较庞大，包含了很多if-else语句，这些语句需要覆盖所有的逻辑分支。
  •  calculateBonus函数缺乏弹性，如果增加了一种新的绩效等级C，或者想把绩效S的奖金系数改为5，那我们必须深入calculateBonus函数的内部实现，这是违反开放-封闭原则的。
  • 算法的复用性差，如果在程序的其他地方需要重用这些计算奖金的算法呢？我们的选择只有复制和粘贴。

2．使用组合函数重构代码

一般最容易想到的办法就是使用组合函数来重构代码，我们把各种算法封装到一个个的小函数里面，这些小函数有着良好的命名，可以一目了然地知道它对应着哪种算法，它们也可以被复用在程序的其他地方。代码如下：

var performanceS = function( salary ){
  return salary * 4;
};

var performanceA = function( salary ){
  return salary * 3;
};

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

var calculateBonus = function( performanceLevel, salary ){

  if ( performanceLevel === 'S' ){
    return performanceS( salary );
  }

  if ( performanceLevel === 'A' ){
    return performanceA( salary );
  }

  if ( performanceLevel === 'B' ){
    return performanceB( salary );
  }

};

calculateBonus(  'A' , 10000 );    // 输出：30000

目前，我们的程序得到了一定的改善，但这种改善非常有限，我们依然没有解决最重要的问题：calculateBonus函数有可能越来越庞大，而且在系统变化的时候缺乏弹性。

3．使用策略模式重构代码

经过思考，我们想到了更好的办法——使用策略模式来重构代码。策略模式指的是定义一系列的算法，把它们一个个封装起来。将不变的部分和变化的部分隔开是每个设计模式的主题，策略模式也不例外，策略模式的目的就是将算法的使用与算法的实现分离开来。

传统面向对象语言中的实现：

class PerformanceS {
	calculate(salary) {
  	return salary * 4;
  }
}

class PerformanceA {
	calculate(salary) {
  	return salary * 3;
  }
}

class PerformanceB {
	calculate(salary) {
  	return salary * 2;
  }
}

class Bonus {
	constructor() {
    this.salary = null;      // 原始工资
  	this.strategy = null;    // 绩效等级对应的策略对象
  }
  setSalary(salary) {
  	this.salary = salary;    // 设置员工的原始工资
  }
  setStrategy(strategy) {
  	this.strategy = strategy;    // 设置员工绩效等级对应的策略对象
  }
  getBonus() {  // 取得奖金数额
  	 return this.strategy.calculate( this.salary );    // 把计算奖金的操作委托给对应的策略对象
  }
}

let bonus = new Bonus();

bonus.setSalary( 10000 );
bonus.setStrategy( new PerformanceS() );  // 设置策略对象

console.log( bonus.getBonus() );    // 输出：40000

bonus.setStrategy( new PerformanceA() );  // 设置策略对象
console.log( bonus.getBonus() );    // 输出：30000

JavaScript版本的策略模式：

var strategies = {
  "S": function( salary ){
    return salary * 4;
  },
  "A": function( salary ){
    return salary * 3;
  },
  "B": function( salary ){
    return salary * 2;
  }
};

var calculateBonus = function( level, salary ){
  return strategies[ level ]( salary );
};

console.log( calculateBonus( 'S', 20000 ) );     // 输出：80000
console.log( calculateBonus( 'A', 10000 ) );     // 输出：30000

我们用策略模式重构了这段计算年终奖的代码，可以看到通过策略模式重构之后，代码变得更加清晰，各个类的职责更加鲜明。

总结

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

avatar
文章
阅读
粉丝