摘要：策略模式的優缺點優點策略模式利用組合，委托和多態等技術思想，可以有效避免多重條件選擇語句。策略模式提供了對開放封閉原則的完美支持。策略模式會向用戶暴露所有實現細節，這其實是違反最少知識原則。

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

在現實中，如果我們想去某個地方旅游，可以根據實際情況有多種路線

如果沒有時間但是不在乎錢，可以選擇飛機

如果沒有錢，可以選擇大巴活著火車

如果再窮一點，可以選擇騎自行車

現在以年終獎的計算為例

公司年終獎根據員工的工資基數和年底績效來發放

績效S,四倍年終獎

績效A,三倍年終獎

績效B,二倍年終獎

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", 2000) // 4000
calculateBonus("S", 2000) // 8000

這段代碼簡單，但是存在顯而易見的缺點

函數比較龐大，包含很多if-else語句，這些語句需要覆蓋所有的邏輯分支

缺乏彈性,如果想新增績效C，就得深入函數內部實現，違反開放-封閉原則

算法的復用性差

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", 2000)) // 8000
console.log(calculateBonus("B", 2000)) // 4000

通過使用策略模式重構代碼，消除來原程序中分支語句。所有計算獎金有關的邏輯分布在策略對象中，每個策略對象的算法已被各自封裝在對象內部，當我們對這些策略對象發出“計算獎金”的請求時，它們會返回各自的計算結果，這不僅是多態性的體現，也是“自由交換”的目的。

    
        
        
        
    
    
    
我說div
        
    

從定義上看，策略模式就是用來封裝算法的。但是如果僅僅用來封裝算法，未免有點大材小用。在實際業務中，策略模式也可以用來封裝一系列的“業務規則”。只要業務規則指向的目標一致，并且可以被替換使用，我們就可以用策略模式來封裝它們。

    
    
    



    請輸入用戶名

    請輸入密碼

    請輸入手機號

    

    

這是一種很常見的編碼方式，可以看到缺點和計算獎金一摸一樣

很明顯第一步我們需要將驗證邏輯封裝成策略對象

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

接下來實現Validator類,負責接受用戶的請求并委托給strategies

var Validator = function() {
    //保存校驗規則
    this.cache = [] 
}

// 添加校驗
Validator.prototype.add = function(dom, rules) {
    var self = this
    // 遍歷校驗規則
    for(var i = 0, rule; rule = rules[i++];) { 
        (function(rule){
            //把strategy和參數分開
            var strategyAry = rule.strategy.split(":")     
            var errorMsg = rule.errorMsg    
            // 把校驗的步驟用空函數包裝起來，并且放入cache
            self.cache.push(function(){    
                // 挑選出校驗規則
                var strategy = strategyAry.shift()
                // 把input的value添加進參數列表
                strategyAry.unshift(dom.value)        
                // 把errorMsg添加進參數列表
                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: "isNonEmpty",
                errorMsg: "用戶名不能為空"
            },
            {
                strategy: "minLength:10",
                errorMsg: "用戶名長度不能小于10位"                        
            }
        ]
    )
    validator.add(registerForm.password, [
            {
                strategy: "minLength:6",
                errorMsg: "密碼長度不能小于6位"                        
            }
        ]
    )
    validator.add(registerForm.phonenumber, [
            {
                strategy: "isMobile",
                errorMsg: "手機號碼格式不正確"                        
            }
        ]
    )                                
    var errorMsg = validator.start()
    return errorMsg                            
}

var sub = document.querySelector("input[type="submit"]")
sub.onclick = function() {
    var errorMsg = validataFunc()
    if (errorMsg) {
        console.error(errorMsg)
        return false
    }
}

使用策略模式重構代碼之后，我們不僅通過“配置”的方式就可以完成一個表單的校驗，這些規則也可以復用在程序的任何地方，還能以插件的形式，方便地移植到其他項目中。并且新增或者修改規則也是毫不費力的。

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

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

策略模式中的算法也可以復用在系統中的其他地方。

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

使用策略對象會增加很多策略類或者策略對象，但實際上比把這些邏輯放在Content更好。

策略模式會向用戶暴露所有實現細節，這其實是違反最少知識原則。