提升代码可读性，减少if-else

1、短路运算

JavaScript的逻辑或 || 的短路运算有时候可以用来代替一些简单的 if else
· 逻辑或 || 的短路运算：若左边能转成true，返回左边的值，否则返回右边的值。
例如：

let c
if(a) {
    c = a
} else {
 c = b
}

这里可以用逻辑或来替代

let c = a || b

2、三元运算符

使用三元运算符来提高代码可读性，一般提倡只用一层，太多层次反而会影响代码可读性
例如：

const fn = nBoolean => {
    if (nBoolean) {
        return 1
    } else {
        return 0
    }
}

// 替换成三元运算符
const fn = nBoolean => {
    return nBoolean ? 1 : 0
}

条件赋值、递归等也可以用三元运算符

// num值在nBoolean为true时期10，否则为5
let num = nBoolean ? 10 : 5

// 求0-n之间的整数的和
let sum = 0
function add(n) {
    sum += n
    return n >= 2 ? add(n-1) : result
}
let num = add(10)

3、switch case

switch case 虽然比 else if 的可读性要高，但是写起来比较麻烦。
例如：有a、b、c、d四种类型，在a、b的时候输出1，c的时候输出2，d输出3，默认输出0

let type = 'a'

// 使用if else的写法
if (type == 'a' || type == 'b') {
    console.log(1)
} else if (type == 'c') {
    console.log(2)
} else if (type == 'd'){
    console.log(3)
} else {
    console.log(0)
}

// 使用switch case的写法
switch (type) {
    case 'a':
    case 'b':
        console.log(1)
        break
    case 'c':
        console.log(2)
        break
    case 'd':
        console.log(3)
        break
    default:
        console.log(0)
}

4、对象配置/策略模式

对象配置看起来跟 策略模式 差不多，都是根据不同的参数使用不同的数据/算法/函数。

策略模式就是将一系列算法封装起来，并使他们之间可以替换。被封装起来的算法具有独立性，外部不可改变其特性。
例如：

let type = 'a'
let tactics = {
    'a': 1,
    'b': 1,
    'c': 2,
    'd': 3,
    default: 0
}
console.log(tactics[type]) // 1

用实例来体现对象配置/策略模式：

1. 案例1：商场促销价
   根据不同的用户使用不同的折扣，如：普通用户不打折，普通会员打9折，年费会员8.5折，超级会员8折
   使用 if else 实现：

   // 获取折扣 --- 使用 if else
   const getDiscount = userKey => {
    if (userKey == '普通会员') {
        return 0.9
    } else if(userKey == '年费会员') {
        return 0.85
    } else if(userKey == '超级会员') {
        return 0.8
    } else{
        return 1
    }
   }
   console.log(getDiscount('普通会员')) // 0.9

   使用对象配置/策略模式实现

   // 获取折扣 -- 使用对象配置/策略模式
   const getDiscount = userKey => {
    // 根据用户类型生成折扣对象
    let discounts = {
        '普通会员': 0.9,
        '年费会员': 0.85,
        '超级会员': 0.8,
        'default': 1,
    }
    return discounts[userKey] || discounts['default']
   }
   console.log(getDiscount('普通会员')) // 0.9

2. 案例2：年终奖
   假设绩效为A的人年终奖为4倍工资，绩效为B的3倍，绩效为C的2倍。用代码实现逻辑，实现如下：

   const getBonus = (leval, salary) => {
    if(leval == 'A') {
        return salary*4
    } 
    if (leval == 'B') {
        return salary * 3
    }
    if(leval == 'C') {
        return salary * 2
    }
   }
   getBonus('B', 20000) // 60000

   上面代码简单，但是里面可能会有很多的 if else ，如果增加了新的绩效，或者更改设定好的倍数，就需要从头到尾阅读代码后才能进行修改。
   如果使用对象配置/策略模式去简化这个函数。就会使得代码更方便修改。

   let strategies = new Map([
    ['A', 4],
    ['B', 3],
    ['C', 2]
   ])
   const getBonus = (leval, salary) => {
    return strategies.get(leval) * salary
   }
   getBonus('B', 20000) // 60000

   如果此时需求在增加一个条件，根据部门进行年终奖评定，例如公司有两个部门D和F，D部门的业绩更好，所以年终奖翻1.2倍，F部门业绩稍差，年终奖打9折。
   这个时候，再改造对象配置/策略模式下的代码，把状态值拼接，然后存入Map中

   let strategies = new Map([
    ['A_D', 4 * 1.2],
    ['B_D', 3 * 1.2],
    ['C_D', 2 * 1.2],
    ['A_F', 4 * 0.9],
    ['B_F', 3 * 0.9],
    ['C_F', 2 * 0.9]
   ])
   const getBonus = (leval, salary, department) => {
    return strategies.get(`${leval}_${department}`)*salary
   }
   getBonus('A', 20000, 'F') // 720000

   以上，就是一些小技巧。希望能帮到更多有缘人。