摘要：實際上在這種將函數作為一等對象的語言里，策略模式已經融入到了語言本身當中，我們經常使用高階函數來封裝不同的行為，并且把它傳遞到另一個函數中。

聲明：這個系列為閱讀《JavaScript設計模式與開發實踐》 ----曾探@著一書的讀書筆記

將不變的部分和變化的部分隔開是每個設計模式的主題。

定義一系列的算法，把它們一個個封裝起來，并且使它們可以相互替換。

將算法的使用與算法的實現分離開來。

使用策略模式來實現計算獎金

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 (strategy) {
    this.strategy=strategy;//設置績效等級對應的策略對象
};


Bonus.prototype.getBonus =function () { //取得獎金數額
    return this.strategy.calculate(this.salary);//把計算獎金的操作委托給對應的策略對象
};




var bonus = new Bonus();
bonus.setSalary(10000);
bonus.setStrategy(new performances());//設置策略對象

console.log(bonus.getBonus());

bonus.setStrategy(new performanceA());

console.log(bonus.getBonus());

定義有系列的算法，把它們各自封裝成策略類，算法被封裝在策略類內部的方法里。在客戶端對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);
};

console.log(calculateBonus("S",1000));
console.log(calculateBonus("A",4000));

使用策略模式重構代碼，可以消除程序中大片的條件分支語句。在實際開發中，我們通常會把算法的含義擴散開來，使策略模式也可以用來封裝一系列的“業務規則”。只要這些業務規則指向的目標一致，并且可以被替換使用，我們就可以使用策略模式來封裝他們。

//策略對象

var strategies = {
    isNonEmpty: function (value, errorMsg){
        if (value === "") {
            return errorMsg;
        }
    },
    minLength: function (value, length, errorMg){
        if (value.length < length) {
            return errorMg;
        }
    },
    isMobile: function (value, errorMsg){
        if (!/(^1[3|5|8][0-9]{9}$)/.test(value)) {
            return errorMsg;
        }
    }
};



/**
 * Validator 類
 * @constructor
 */
var Validator = function (){
    this.cache = [];
};

Validator.prototype.add = function (dom, rules){
    var self = this;

    for (var i = 0, rule; rule = rules[i++];) {
        (function (rule){
            var strategyAry=rule.strategy.split(":");
            var errorMsg=rule.errorMsg;

            self.cache.push(function (){
                var strategy=strategyAry.shift();
                strategyAry.unshift(dom.value);
                strategyAry.push(errorMsg);
                return strategies[strategy].apply(dom,strategyAry);
            })
        })(rule)
    }
};

Validator.prototype.start=function (){
    for (var i=0,validatorFunc;validatorFunc=this.cache[i++];){
        var errorMsg=validatorFunc();
        if(errorMsg){
            return errorMsg;
        }
    }
};

//客戶端調用的代碼

var registerForm=document.getElementById("registerForm");
var validataFunc=function (){
    var validator=new Validator();

    validator.add(registerForm.userName,[{
        "strategy":"isNonEnpty",
        "errorMsg":"用戶名不能為空"
    },{
        "strategy":"minLength",
        "errorMsg":"用戶名長度不能小于10位"
    }]);

    // validator.add(registerForm.password,[])

    var errorMsg =validator.start();
    return errorMsg;

};

registerForm.onsubmit=function (){
    var errorMsg=validataFunc();

    if(errorMsg){
        alert(errorMsg);
        return false;
    }
};

優點：

策略模式利用組合，委托和多態等技術思想，可以有效的避免多重條件選擇語句；

策略模式提供了對開放-封閉原則的完美支持，將算法封裝在獨立的strategy中，使得它們易于切換，易于理解，易于擴展。

策略模式中的算法也可以復用在系統的其它地方，從而避免許多重復的復制粘貼工作。

在策略模式中利用組合和委托來讓Context擁有執行算法的能力，這也是繼承的一種更輕便的替代方案。

缺點：

策略模式會在程序中添加許多的策略類和策略對象

要使用策略模式，就必須要了解各個strategy和他們之間的不同點，這樣才能選擇一個合適的strategy。

在函數作為一等對象的語言中，策略模式是隱形的。strategy就是值為函數的變量。

在JavaScript中，除了使用類來封裝算法和行為之外，使用函數當然也是一種選擇。這些“算法”可以被封裝到函數中并且四處傳遞，也就是我們常說的“高階函數”。

實際上在JavaScript這種將函數作為一等對象的語言里，策略模式已經融入到了語言本身當中，我們經常使用高階函數來封裝不同的行為，并且把它傳遞到另一個函數中。當我們對這些函數發出“調用”的消息時，不同的函數會返回不同的執行結果。所以在JavaScript中，“函數對象的多態性”會更加簡單些。

在JavaScript語言的策略模式中，策略類往往被函數所代替，這時策略模式就成了一種“隱形”的模式。