JavaScript複雜判斷(if else / switch)的更優雅寫法優化冗餘

時間 2019-11-06

標籤 javascript 複雜判斷 switch 優雅寫法優化冗餘欄目 JavaScript 简体版

原文原文鏈接

前提

咱們編寫js程式碼時常常遇到複雜邏輯判斷的狀況，一般你們能夠用if/else或者switch來實現多個條件判斷，但這樣會有個問題，隨着邏輯複雜度的增長，程式碼中的if/else/switch會變得愈來愈臃腫，愈來愈看不懂，那麼如何更優雅的寫判斷邏輯，本文帶你試一下。javascript

舉個例子

先看一段程式碼html

/**
 * 按鈕點選事件
 * @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出場：java

/** 
 * 按鈕點選事件
 * @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的邏輯。es6

這時有同窗會說，還有更簡單的寫法：ide

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）
}

上面程式碼確實看起來更清爽了，這種方法的聰明之處在於：將判斷條件做爲對象的屬性名，將處理邏輯做爲對象的屬性值，在按鈕點選的時候，經過對象屬性查詢的方式來進行邏輯判斷，這種寫法特別適合一元條件判斷的狀況。優化

是否是還有其餘寫法呢？有的：this

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有什麼區別呢？prototype

一個對象一般都有本身的原型，因此一個對象總有一個」prototype」鍵。
一個對象的鍵只能是字串或者Symbols，但一個Map的鍵能夠是任意值。
你能夠經過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 {
       //作某事 
    } 
  } 
}

原諒我不寫每一個判斷裏的具體邏輯了，由於程式碼太冗長了。code

原諒我又用了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))
}

也就是說利用陣列迴圈的特性，符合正則條件的邏輯都會被執行，那就能夠同時執行公共邏輯和單獨邏輯，由於正則的存在，你能夠開啓想象力解鎖更多的玩法，本文就不贅述了。