以年终公司员工奖金为题
简单写法
var calculateBonus = function( performanceLevel, salary ){
if ( performanceLevel === 'A' ){
return salary * 4;
}
if ( performanceLevel === 'B' ){
return salary * 3;
}
if ( performanceLevel === 'C' ){
return salary * 2;
}
};
calculateBonus( 'B', 20000 ); // 输出：40000
calculateBonus( 'S', 6000 ); // 输出：24000
可以发现，这段代码十分简单，但是存在着明显的缺点：
- calculateBonus函数比较庞大，包含了很多if-else语句，这些语句需要覆盖所有的逻辑分支。
- calculateBonus函数缺乏弹性，如果增加了一种新的绩效等级D，或者把A等级的倍数改成5，那我们必须深入。
- calculateBonus函数的内部实现，这是违反开放-封闭原则的。
- 算法的复用性差，如果在程序的其他地方需要重用这些计算奖金的算法呢？我们的选择只有复制和粘贴。因此，我们需要重构这段代码。
进阶-组合函数重构代码
var performanceA = function( salary ){
return salary * 4;
};
var performanceB = function( salary ){
return salary * 3;
};
var performanceC = function( salary ){
return salary * 2;
};
var calculateBonus = function( performanceLevel, salary ){
if ( performanceLevel === 'A' ){
return performanceA( salary );
}
if ( performanceLevel === 'B' ){
return performanceB( salary );
}
if ( performanceLevel === 'C' ){
return performanceC( salary );
}
};
calculateBonus( 'A' , 10000 ); // 输出：40000
目前，我们的程序得到了一定的改善，但这种改善非常有限，我们依然没有解决最重要的问题：calculateBonus函数有可能越来越庞大，而且在系统变化的时候缺乏弹性。
终极-策略模式
每种绩效的计算规则:
var performanceA = function() {};
performanceA.prototype.calculate = function (salary) {
return salary * 4
}
var performanceB = function(){};
performanceB.prototype.calculate = function( salary ){
return salary * 3;
};
var performanceC = function(){};
performanceC.prototype.calculate = 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.calculate( this.salary ); // 把计算奖金的操作委托给对应的策略对象
};
调用输出
var bonus = new Bonus();
bonus.setSalary( 10000 );
bonus.setStrategy( new performanceA() ); //设置策略对象
console.log( bonus.getBonus() ); // 输出：40000
bonus.setStrategy( new performanceB() ); //设置策略对象
console.log( bonus.getBonus() ); // 输出：30000
JavaScript实现策略模式
var strategies = {
"A": function( salary ){
return salary * 4;
},
"B": function( salary ){
return salary * 3;
},
"C": function( salary ){
return salary * 2;
}
};
var calculateBonus = function( level, salary ){
return strategies[level](salary)
};
console.log( calculateBonus( 'A', 20000 ) ); // 输出： 80000
console.log( calculateBonus( 'B', 10000 ) ); // 输出： 30000
优点
- 策略模式利用组合、委托和多态等技术和思想，可以有效地避免多重条件选择语句。
- 策略模式提供了对开放—封闭原则的完美支持，将算法封装在独立的strategy中，使得它们易于切换，易于理解，易于扩展。
- 策略模式中的算法也可以复用在系统的其他地方，从而避免许多重复的复制粘贴工作。
- 在策略模式中利用组合和委托来让Context拥有执行算法的能力，这也是继承的一种更轻便的替代方案。
- 解耦
缺点
首先，使用策略模式会在程序中增加许多策略类或者策略对象，但实际上这比把它们负责的逻辑堆砌在Context中要好。 其次，要使用策略模式，必须了解所有的strategy（策略的名字要通过API暴露），必须了解各个strategy之间的不同点，这样才能选择一个合适的strategy。比如，我们要选择一种合适的旅游出行路线，必须先了解选 择飞机、火车、自行车等方案的细节。此时strategy要向客户暴露它的所有实现，这是违反最少知识原则的。
