提升代码的可读性

使用短路运算 ||

逻辑或||的短路运算：若左边能转成true，则返回左边的值。反之返回右边的值。

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

使用短路运算符

let a = b||c

三元运算符

一些简单的判断使用三元运算符，建议只使用一层

//条件：为true时返回1，反之返回0
const fun=(n) {
    if(n){
    return 1
    }else {
    return 0
    }
}
//使用三元运算符
const fn =(n) {
    return n?1:0
}

三元运算符大多数用于：条件赋值、递归。。。

//条件赋值
let num=nBool?1:0
//计算总和
let sum=0;
function add(n) {
    sum+=n
    return n>=2?add(n-1):1;
};
add(10);
console.log(sum) //55

switch case

上面两种方式，只能用于简单的判断。switch case用于多重判断

 let char='A'
     if(char=='A'||char=='B') {
      console.log(1);
    } else if (char=='C') {
      console.log(2);
    } else if(char=='D') {
      console.log(3);
    } else {
      console.log(0)
    }
//使用switch case实现
   
    switch(char) {
      case 'A':
      case 'B':
          console.log(1)
          break;
      case 'C':
        console.log(2)
        break;
      case 'D':
        console.log(3)
        break;
      default:
        console.log(0);
    }

对象配置/策略模式

对象配置看起来跟策略模式差不多，都是根据不同的参数使用不同的数据/算法/函数。 策略模式就是将一系列算法封装起来，并使他们相互之间可以替换。被封装的算法具有独立性，外部不可改变其特性。 对象配置：

    let char='A'
    let type={
      'A':1,
      'B':1,
      'C':2,
      'D':3,
      default:0
    }
    console.log(type[char]);

实战案例

案例1：商场促销价

要求：根据不同的用户使用不同的折扣，普通用户不打折扣，普通会员9折，年费会员8.5折，超级会员8折。

//使用if else实现
    const getDiscount=(userkey) =>{
     if (userkey=='普通会员'){
        return 0.9;
      } else if(userkey=='年费会员') {
        return 0.95;
      } else if (userkey=='超级会员') {
        return 0.8;
      } else {
        return 1;
      }
    }
    console.log(getDiscount('普通会员'))
//使用对象配置/策略模式实现
    const getDiscount=(userkey)=>{
      let discount={
        '普通会员':0.9,
        '年费会员':0.85,
        '超级会员':0.8,
        'default':1
      }
      return discount[userkey]||discount['default']
    }
    console.log(getDiscount('超级会员'));
//对象配置不一定用对象去管理键值对，可以使用Map来管理
    const getDiscount=(userkey)=>{
      let discount=new Map([
        ['普通会员',0.9],
        ['年费会员',0.95],
        ['超级会员',0.85],
        ['default',1]
      ])
      return discount.get(userkey)||discount.get('default')
    }
    console.log(getDiscount('普通用户'));

案例二：年终奖

根据员工的工资基数，绩效为A的人年终奖有4倍工资，绩效为B的人年终奖有3倍工资，绩效为C的人年终奖有2倍工资

//使用if else
    const calculateBonus=(performanceLevel,salary)=>{
      if(performanceLevel=='A') {
        return salary*4
      } else if (performanceLevel=='B') {
        return salary*3
      } else if (performanceLevel=='C') {
        return salary*2
      }
    }
    console.log(calculateBonus('A',20000));
//使用对象配置
    let strategies=new Map([
      ['A',4],
      ['B',3],
      ['C',2],
      ['default',1]
    ])
    const calculateBonus=(performanceLevel,salary)=>{
      return (strategies.get(performanceLevel)||strategies.get('default'))*salary 
    }
    console.log(calculateBonus('D',20000));

假设公司有两个部门D和F，D部门的业绩好，年终奖翻1.2倍。F部门的业绩差，年终奖打9折。

//以绩效_部门的方式拼接键值存入
    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],
      ['default',1]
    ])
    const calculateBonus=(performanceLevel,salary,department)=>{
      return (strategies.get(`${performanceLevel}_${department}`)||strategies.get('default'))*salary 
    }
    console.log(calculateBonus('A',20000,'D'));