JavaScript复杂判断(if else / switch)的更优雅写法优化冗余

前提

我们编写js程式码时经常遇到复杂逻辑判断的情况，通常大家可以用if/else或者switch来实现多个条件判断，但这样会有个问题，随着逻辑复杂度的增加，程式码中的if/else/switch会变得越来越臃肿，越来越看不懂，那么如何更优雅的写判断逻辑，本文带你试一下。

举个例子

先看一段程式码

/** * 按钮点选事件 * @param {number} status活动状态：1开团进行中2开团失败3商品售罄4开团成功5系统取消 */ const onButtonClick = ( status )=> { if (status == 1 ){ sendLog( 'processing' ) jumpTo( 'IndexPage' ) } else if (status == 2 ){ sendLog( 'fail' ) jumpTo( 'FailPage' ) } else if (status == 3 ) { sendLog( 'fail' ) jumpTo('FailPage'） } else if（status== 4）{ sendLog（'success'） jumpTo（'SuccessPage'） } 否则 if（status == 5）{ sendLog（'cancel'） jumpTo（'CancelPage'） } else { sendLog（'other'） jumpTo（'Index'） } }

通过程式码可以看到这个按钮的点选逻辑：根据不同活动状态做两件事情，传送日志埋点和跳转到对应页面，大家可以很轻易的提出这段程式码的改写方案，switch出场：

/** * 按钮点选事件 * @param {number} status活动状态：1开团进行中2开团失败3商品售罄4开团成功5系统取消 */ const onButtonClick = ( status )=> { switch (status){ case 1 : sendLog( 'processing' ) jumpTo( 'IndexPage' ) break; case 2 : case 3 : sendLog( 'fail' ) jumpTo( 'FailPage' ) break; case 4 : sendLog( 'success' ) jumpTo（'SuccessPage'） break; case 5： sendLog（'cancel'） jumpTo（'CancelPage'） break; default： sendLog（'other'） jumpTo（'Index'） break; } }

嗯，这样看起来比if/else清晰多了，细心的同学也发现了小技巧，case 2和case 3逻辑一样的时候，可以省去执行语句和break，则case 2的情况自动执行case 3的逻辑。

这时有同学会说，还有更简单的写法：

const actions = { '1'：[ 'processing'，'IndexPage' ]， '2'：[ 'fail'，'FailPage' ]， '3'：[ 'fail'，'FailPage' ]， '4'：[ 'success'，'SuccessPage' ]， '5'：[ 'cancel'，'CancelPage' ]， 'default'：[ 'other'，'Index' ]， } /** * 按钮点选事件 * @param {number} status活动状态：1开团进行中2开团失败3商品售罄4开团成功5系统取消 */ const onButtonClick = （status）=> { let action = actions [status] || actions [ 'default' ]， logName = action [ 0 ]， pageName = action [ 1 ]; sendLog（logName） jumpTo（pageName） }

上面程式码确实看起来更清爽了，这种方法的聪明之处在于：将判断条件作为对象的属性名，将处理逻辑作为对象的属性值，在按钮点选的时候，通过对象属性查询的方式来进行逻辑判断，这种写法特别适合一元条件判断的情况。

是不是还有其他写法呢？有的：

const actions = new Map（[ [ 1，[ 'processing'，'IndexPage' ]]， [ 2，[ 'fail'，'FailPage' ]]， [ 3，[ 'fail'，'FailPage' ]]， [ 4，[ 'success'，'SuccessPage' ]]， [ 5，[ 'cancel'，'CancelPage' ]]， [ 'default'，[ 'other'，'Index']] ]） / * * * 按钮点选事件 * @param {number} status活动状态：1开团进行中2开团失败3商品售罄4开团成功5系统取消 */ const onButtonClick = ( status )=> { let action = actions .get(status) || actions.get( 'default' ) ; sendLog(action[ 0 ]) jumpTo(action[ 1 ]) }

这样写用到了es6里的Map物件，是不是更爽了？Map物件和Object有什么区别呢？

1. 一个对象通常都有自己的原型，所以一个对象总有一个”prototype”键。
2. 一个对象的键只能是字串或者Symbols，但一个Map的键可以是任意值。
3. 你可以通过size属性很容易地得到一个Map的键值对个数，而对象的键值对个数只能手动确认。

我们需要把问题升级一下，以前按钮点选时候只需要判断status，现在还需要判断使用者的身份：

/* * * 按钮点选事件 * @param {number} status活动状态：1开团进行中2开团失败3开团成功4商品售罄5有库存未开团 * @param {string} identity身份标识： guest客态master主态 */ const onButtonClick = (status,identity)=>{ if (identity == 'guest' ){ if (status == 1 ){ //do sth } else if (status == 2 ) { //do sth } else if (status == 3 ){ //do sth } else if (status == 4）{ //做某事 } else if（status== 5）{ //做某事 } else { //做某事 } } else if（identity == 'master'）{ if（status == 1）{ //做某事 } else if（status== 2）{ //做某事 } 其他 if（status== 3）{ //做某事 } else if（status== 4 } { //做某事 } else if（状态== 5）{ //做某事 } else { //做某事 } } }

原谅我不写每个判断里的具体逻辑了，因为程式码太冗长了。

原谅我又用了if/else，因为我看到很多人依然在用if/else写这种大段的逻辑判断。

从上面的例子我们可以看到，当你的逻辑升级为二元判断时，你的判断量会加倍，你的程式码量也会加倍，这时怎么写更清爽呢？

const actions = new Map（[ [ 'guest_1',（）=> { / * do sth * / }], [ 'guest_2',（）=> { / * do sth * / }], [ 'guest_3',（）=> { / *做某事* / }], [ 'guest_4',（）=> { / *做某事* / }], [ 'guest_5',（）=> { / *做某事* / } ], [ 'master_1',（）=> { / *做某事* / }], [ 'master_2',（）=> { / *做某事* / }], [ 'master_3',（）=> { / *做某事* /}], [ 'master_4', () => { /*do sth*/ }], [ 'master_5', () => { /*do sth*/ }], [ 'default', () => { /*do sth*/ }], ]) /* * javascript * 按钮点选事件 * @param {string} identity身份标识：guest客态master主态 * @param {number} status活动状态：1开团进行中2开团失败3开团成功4商品售罄5有库存未开团 */ const onButtonClick = (identity,status)=>{ let action = actions.get(`${identity}_${status}` ) || actions.get( 'default' ) action.call(this) }

上述程式码核心逻辑是：把两个条件拼接成字串，并通过以条件拼接字串作为键，以处理函式作为值的Map进行查询并执行，这种写法在多元条件判断时候尤其好用。

当然上述程式码如果用Object来实现也是类似的：

const actions = { 'guest_1':()=>{/*do sth*/}, 'guest_2':()=>{/*do sth*/}, //.... } const onButtonClick = (identity,status)=>{ let action = actions[`${identity}_${status}`] || actions['default'] action.call(this) }

如果有些同学觉得把查询条件拼成字串有点别扭，那还有一种方案，就是用Map，以Object作为key：

const actions = new Map([ [{identity:'guest',status:1},()=>{/*do sth*/}], [{identity:'guest',status:2},()=>{/*do sth*/}], //... ]) const onButtonClick = (identity,status)=>{ let action = [...actions].filter(([key,value])=>(key.identity == identity && key.status == status)) action.forEach(([key,value])=>value.call(this)) }

是不是又高阶了一点点？

这里也看出来Map与Object的区别，Map可以用任何型别的资料作为key。

我们现在再将难度升级一点点，假如guest情况下，status1-4的处理逻辑都一样怎么办，最差的情况是这样：

const actions = new Map（[ [{identity：'guest'，status：1 }，（）=> { / * functionA * / }]， [{identity：'guest'，status：2 }，（）=> { / * functionA * / }]， [{identity：'guest'，status：3 }，（）=> { / * functionA * / }]， [{identity：'guest'，status：4 }，（）=> { / * functionA * / }]， [{identity：'guest'，status：5 }，（）=> { / * functionB * / }]， // ... ]）

好一点的写法是将处理逻辑函式进行快取：

const actions = ()=>{ const functionA = ()=>{/*do sth*/} const functionB = ()=>{/*do sth*/} return new Map([ [{identity:'guest',status:1},functionA], [{identity:'guest',status:2},functionA], [{identity:'guest',status:3},functionA], [{identity:'guest',status:4},functionA], [{identity:'guest',status:5},functionB], //... ]) } const onButtonClick = (identity,status)=>{ let action = [...actions()].filter(([key,value])=>(key.identity == identity && key.status == status)) action.forEach(([key,value])=>value.call(this)) }

这样写已经能满足日常需求了，但认真一点讲，上面重写了4次functionA还是有点不爽，假如判断条件变得特别复杂，比如identity有3种状态，status有10种状态，那你需要定义30条处理逻辑，而往往这些逻辑里面很多都是相同的，这似乎也是笔者不想接受的，那可以这样实现:

const actions = ()=>{ const functionA = ()=>{/*do sth*/} const functionB = ()=>{/*do sth*/} return new Map([ [/^guest_[1-4]$/,functionA], [/^guest_5$/,functionB], //... ]) } const onButtonClick = (identity,status)=>{ let action = [...actions()].filter(([key,value])=>(key.test(`${identity}_${status}`))) action.forEach(([key,value])=>value.call(this)) }

这里Map的优势更加凸显，可以用正则作为key了，这样就有了无限可能，假如需求变成，凡是guest情况都要传送一个日志埋点，不同status情况也需要单独的逻辑处理，那我们可以这样写:

const actions = ()=>{ const functionA = ()=>{/*do sth*/} const functionB = ()=>{/*do sth*/} const functionC = ()=>{/*send log*/} return new Map([ [/^guest_[1-4]$/,functionA], [/^guest_5$/,functionB], [/^guest_.*$/,functionC], //... ]) } const onButtonClick = (identity,status)=>{ let action = [...actions()].filter(([key,value])=>(key.test(`${identity}_${status}`))) action.forEach(([key,value])=>value.call(this)) }

也就是说利用阵列回圈的特性，符合正则条件的逻辑都会被执行，那就可以同时执行公共逻辑和单独逻辑，因为正则的存在，你可以开启想象力解锁更多的玩法，本文就不赘述了。

总结

本文已经教你了8种逻辑判断写法，包括：

1. 如果别的
2. 开关
3. 一元判断时：存到Object里
4. 一元判断时：存到Map里
5. 多元判断时：将condition拼接成字串存到Object里
6. 多元判断时：将condition拼接成字串存到Map里
7. 多元判断时：将condition存为Object存到Map里
8. 多元判断时：将condition写作正则存到Map里

至此，本文也将告一段落，愿你未来的人生里，不只是有if/else/switch。

原文地址：JavaScript复杂判断(if else / switch)的更优雅写法优化冗余