设计模式-策略模式

// 计算年终奖
function getAnnualBonus(type, salary, sales) {
    // 计算typeA年终奖
    if (type === 'typeA') {
      return salary * 0.8 + sales * 0.5
    }
    // 计算typeB年终奖
    if (type === 'typeB') {
      return salary * 1.2 + sales * 0.3
    }
    // 计算typeC年终奖
    if (type === 'typeC') {
      return salary * 2
    }
}

这种类型的代码形式 在一个函数中实现三种比较重的逻辑，可读性和bug排错性都会比较的繁琐，
复用性
对于不同的计算方式，也谈不上复用性，当要在某个地地方需要使用typeA的算法时，除了copy 一遍 别无办法，但是你使用了复制粘贴，同一块逻辑在不同的地方实现，会提高很大的维护成本和出错的可能性，当以后需要修改typeA的计算逻辑，就需要多个位置修改看有可能出现改的不一致或者漏改的情况，提高出错概率

造成这个问题的原因时 违背了 单一职责原则

也违背了开放封闭原则
假设我们现在需要新增一种类型，计算方式，之前的代码只能像以下这么改造，

// 计算年终奖
function getAnnualBonus(type, salary, sales) {
    // 计算typeA年终奖
    if (type === 'typeA') {
      return salary * 0.8 + sales * 0.5
    }
    // 计算typeB年终奖
    if (type === 'typeB') {
      return salary * 1.2 + sales * 0.3
    }
    // 计算typeC年终奖
    if (type === 'typeC') {
      return salary * 2
    }
    // 计算typeD年终奖
    if (type === 'typeD') {
      return salary * 3 + sales * 0.2
    }
}

这样子的影响时 修改了原函数，那就许哟啊对于整个流程重新进行一次测试，避免由于其他的问题改到其他的计算方式出错，同时， 越来越多的逻辑集成在一个函数中，造成维护性更加低。

单一职责就是实现每个函数功能独立， 提高了代码的可读性和可复用性，由于函数的粒度变小了，bug调试也会方便许多。

功能独立改造：
// 计算typeA年终奖
const handleTypeA = (salary, sales) => {
    return salary * 0.8 + sales * 0.5
}
// 计算typeB年终奖
const handleTypeB = (salary, sales) => {
    return salary * 1.2 + sales * 0.3
}
// 计算typeC年终奖
const handleTypeC = (salary, sales) => {
    return salary * 2
}

// 计算年终奖
function getAnnualBonus(type, salary, sales) {
    if (type === 'typeA') {
      return handleTypeA(salary, sales)
    }
    if (type === 'typeB') {
      return handleTypeB(salary, sales)
    }
    if (type === 'typeC') {
      return handleTypeC(salary, sales)
    }
}

这样就吧代码的每个部分独立出来，互不影响

拓展开放后，代码如下

const typeMap = {
    // 计算typeA年终奖
    typeA(salary, sales) {
      return salary * 0.8 + sales * 0.5
    },
    // 计算typeB年终奖
    typeB(salary, sales) {
      return salary * 1.2 + sales * 0.3
    },
    // 计算typeC年终奖
    typeC(salary, sales) {
      return salary * 2
    }
}

// 计算年终奖
function getAnnualBonus(type, salary, sales) {
    return typeMap[type](salary, sales)
}

新增的typeD不过就是typeMapde重新拓展的一个类型，二不许哟啊去修改原函数
这样整个计算逻辑不仅消除了大量的if-else 判断逻辑，还实现了很强的代码复用性， 可扩展性，可维护性。

总结
很多的设计模式 总结出来就是 用各种规则在不改变源代码的基础上 去将代码更好的处理独立出来
经过对实例持续优化，决策模式的定时就是定义一系列的算法（计算函数），并把他们一个个封装起来，并且是他们可以相互替换

单一职责原则 将一个个的计算函数独立抽离，
通过 对象的key-value的映射的巧妙方式，使得计算函数可以根据类型进行替换，同时也拥有很强的扩展性。