一、策略模式的定义？
策略模式就是将一系列算法封装起来，并使它们之间相互替换。被封装起来的算法具有独立性外部不可改变其特性。

这里我们以洗衣机为例：洗衣机中存在很多的模式，这些模式都是相互独立的，也就是说单一的一个模式都可以完成洗衣的功能。
下面我们来看一个场景。
如果今天是双十一，商城有促销，促销方案如下。

1、满100减5
2、满200减15
3、满300减30
4、满400减50

此时如果正常代码为：

function full100(price) {
  return price - 5;
}
function full200(price) {
  return price - 15;
}
function full300(price) {
  return price - 30;
}
function full400(price) {
  return price - 50;
}
function calculate (type, price) {
  if (type == 'full100') {
    return full100(price)
  }
  if (type == 'full200') {
    return full200(price)
  }
  if (type == 'full300') {
    return full300(price)
  }
  if (type == 'full400') {
    return full400(price)
  }
}

但是上面代码存在一个缺点就是：一个方法一个if判断，显然，这种方式的扩展性不高。所以我们进行如下修改。

var countPrice = {
  returnPrice: {
    full100: function (price) {
      return price - 5
    },
    full200: function (price) {
      return price - 15
    },
    full300: function (price) {
      return price - 30
    },
    full400: function (price) {
      return price - 50
    }
  },
  getPirce: function (type, money) {
    return this.returnPrice[type] ? this.returnPrice[type](money) : money;
  },
  addRule: function (type, discount) {
    this.returnPrice[type] = function (price) {
      return price - discount;
    }
  }
}

此时我们可以随意的添加规则。
接下来我们查看另一个例子：
表单验证规则：
存在这样一个场景，就是我们需要手动写js的验证规则，来验证表单数据，此时我们可以使用if来进行判断。

function getValue (id) {
  return document.getElementById(id).value;
}
var formData = document.getElementById('form')
formData.onsubmit = function () {
  var name = getValue('username');
  var pwd1 = getValue('password1');
  var pwd2 = getValue('password2');
  var tel = getValue('phone');
  if (name.replace(/(^\s*)|(\s*$)/g, "") === "") {
    alert('用户名不能为空')
    return false
  }
  if (pwd1.replace(/(^\s*)|(\s*$)/g, "")  === "") {
    alert('密码不能为空')
    return false
  }
  if (pwd2.replace(/(^\s*)|(\s*$)/g, "")  === "") {
    alert('确认密码不能为空')
    return false
  }
  if (pwd2 !== pwd1) {
    alert('确认密码与原密码不相同！')
    return false
  }
  if (tel.replace(/(^\s*)|(\s*$)/g, "") === "") {
    alert('手机号码不能为空')
    return false
  }
  if (!/^1[3,4,5,7,8,9][0-9]\d{8}$/.test(tel)) {
    alert('手机号码格式不正确')
    return false
  }
  alert('注册成功')
}

如上所示，代码非常臃肿，并且不宜复用，此时我们可以使用策略模式来解决，将每一个规则封装成一个方法：

function Validate () {}
Validate.prototype.rules = {
  // 是否手机号
  isMobile: function (str) {
    var rule = /^1[3,4,5,7,8,9][0-9]\d{8}$/;
    return rule.test(str);
  },
  // 是否必填
  isRequired: function (str) {
    // 除去首尾空格
    var value = str.replace(/(^\s*)|(\s*$)/g, "");
    return value !== "";
  },
  // 最小长度
  minLength: function (str, length) {
    var strLength = str.length;
    return strLength >= length;
  },
  // 是否相等
  isEqual: function () {
    // 可以接收多个参数比较
    var args = Array.prototype.slice.call(arguments);
    // 取首项与后面所有的项比较，如果每个都相等，就返回true
    var equal = args.every(function(value) {
      return value === args[0];
    })
    return equal;
  }
}

如上所示策略模式的优点有目共睹的，将一个个算法封装起来，提高代码的复用率，减少代码冗余。策略模式可以看做if / else判断的另一种表现形式，在达到相同的目的的同时，极大的减少了代码以及代码的维护成本。