策略模式的定义

定义一系列的算法,把它们一个个封装起来，并且使他们可以相互替换

以计算员工年终奖为例
最初的代码实现

  var calculateBonus = function(performancelevel，salary){
       if(performancelevel === ‘S‘){
           return salary*4；
        }
         if(performancelevel === ‘A‘){
           return salary*3；
        }
         if(performancelevel === ‘B‘){
           return salary*2；
        }
    }
  calculateBonus(S,20000);

使用策略模式重构代码

策略模式的目的是将算法的使用与算法的实现分离开来
策略模式的程序至少由两部分组成：第一部分是一组策略类，策略类封装了具体的算法，并负责具体的计算过程。第二部分是环境类Context接受客户的请求，随后把请求委托给某一个策略类。
Context中要维持对某个策略类的引用

  //定义策略类
   var performanceS = function(){}
    performanceS.prototype.calculate = function(salary）{
        return salary*4；       
  }
  var performanceA = function(){}
    performanceA.prototype.calculate = function(salary）{
        return salary*3；       
  }
  var performanceB = function(){}
    performanceB.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 performanceB());   //对performanceB这个策略类的引用

JavaScript版本的策略模式

在之前在回顾一下策略模式的思想：定义一系列的算法,把它们一个个封装起来，并且使他们可以相互替换
这句话在细说就是：定义一系列的算法，把它们各自封装成策略类，算法被封装在策略类内部的方法里。在客户对Context发起请求的时候，Context总是把请求委托给这些策略对象中间的某一个进行计算。

  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)；
   } 
 
    calculateBonus(‘S‘,10000);

策略模式