js设计模式之策略模式

前沿

上周看了一下js设计模式之策略模式,加上几天的思考,可以来吧啦吧啦一下^_^。

策略模式

首先说一下“策略”这个词,从字面上很好理解,就是做一件事情的方案,比如说:我要出去旅游,就会有多种途径到达目的地。

  1. 如果没有时间但是不在乎钱,可以选择坐飞机。
  2. 如果没有钱,可以选择坐大巴或者火车。
  3. 如果再穷一点,可以选择骑自行车或者11路公交车。

在程序设计中,我们要实现某一个功能有很多种方案。
策略模式的定义是:定义一系列的算法,把它们一个个封装起来,并且使它们可以互相替换。

使用策略模式计算奖金

1、最初的代码实现
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,那我们必须深入calculteBonus函数的内部实现,这是违反开放-封闭原则的。
  • 算法的复用性差,如果在程序的其他地方需要重用这些计算奖金的算法呢?我们选择的只有复制与粘贴。
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、使用策略模式重构代码

策略模式指的是定义一系列的算法,把它们一个个封装起来。将不变的部分和变化的部分隔开是每个设计模式的主题,策略模式的目的就是将算法的使用与算法的实现分离开来。
一个基于策略模式的程序至少有两部分组成。第一部分是一组策略类,策略类封装了具体的算法,并负责具体的计算过程。第二部分是环境类Context,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;
}

接下来定义奖金类Bonus:

var Bonus = function(){
    this.salary = null; //原始工资
    this.strategy = null; //绩效对应的策略对象
}

Bonus.prototype.setSalary = function( salary ){
    this.salary = salary; //设置员工的原始工资
}

Bonus.prototype.setStrategy = function( salary ){
    this.strategy = strategy; //设置员工绩效等级对应的策略
}

Bonus.prototype.getBonus = function(){ //取得奖金数额
    //把计算奖金的操作委托给对应的策略对象
    return this.strategy.calculate( this.salary )
}

var bonus = new Bonus();
bonus.setSalary( 10000 );
bonus.setStrategy( new performanceS() ); //设置策略对象

bonus.getBonus(); //40000

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 );
};

calculateBonus( "S", 20000 ); //80000
calculateBonus( "A", 10000 ); //30000

一等函数对象与策略模式

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

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

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

var calculateBonus = function( func, salary ){
    return fun( salary );
};

calculateBonus( S, 10000 ); //40000

小结

JavaScript语言的策略模式中,策略类往往被函数所代替,这时策略模式就成为一种“隐形”的模式。

相关文章

此处评论已关闭