【轉】轉自微信公衆號 JavaScript 複雜判斷的更優雅寫法

時間 2019-12-11

標籤微信公衆號 javascript 複雜判斷優雅寫法欄目 JavaScript 简体版

原文原文鏈接

與微信公衆號看到一篇js複雜判斷的文章，對我啓發很大，故轉到博客園以供後期不斷學習並應用於項目。原文地址：https://mp.weixin.qq.com/s/ClFDRj4MnAxv1dJ5VWKSJQ

前提

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

舉個例子

先看一段代碼數組

經過代碼能夠看到這個緩存

 1 constonButtonClick=(status)=>{
 2     if(status==1){
 3         sendLog('processing')jumpTo('IndexPage')
 4     }elseif(status==2){
 5         sendLog('fail')jumpTo('FailPage')
 6     }elseif(status==3){
 7         sendLog('fail')jumpTo('FailPage')
 8     }elseif(status==4){
 9         sendLog('success')jumpTo('SuccessPage')
10     }elseif(status==5){
11         sendLog('cancel')jumpTo('CancelPage')
12     }else{
13         sendLog('other')jumpTo('Index')
14     }
15 }

View Code

按鈕的點擊邏輯：根據不一樣活動狀態作兩件事情，發送日誌埋點和跳轉到對應頁面，你們能夠很輕易的提出這段代碼的改寫方案，switch出場：微信

 1 const onButtonClick =
 2 
 3 (status) = >{
 4 
 5     switch
 6 
 7     (status) {
 8 
 9     case
10 
11         1:
12         sendLog('processing') jumpTo('IndexPage')
13 
14         break
15 
16     case
17 
18         2:
19 
20     case
21 
22         3:
23         sendLog('fail') jumpTo('FailPage')
24 
25         break
26 
27     case
28 
29         4:
30         sendLog('success') jumpTo('SuccessPage')
31 
32         break
33 
34     case
35 
36         5:
37         sendLog('cancel') jumpTo('CancelPage')
38 
39         break
40 
41     default:
42         sendLog('other') jumpTo('Index')
43 
44         break
45 
46     }
47 }

View Code

嗯，這樣看起來比if/else清晰多了，細心的同窗也發現了小技巧，case 2和case 3邏輯同樣的時候，能夠省去執行語句和break，則case 2的狀況自動執行case 3的邏輯。ide

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

 1 const actions ={
 2     '1':['processing', 'IndexPage'],
 3     '2':['fail', 'FailPage'],
 4     '3':['fail', 'FailPage'],
 5     '4':['success', 'SuccessPage'],
 6     '5':['cancel', 'CancelPage'],
 7     'default':['other', 'Index'],
 8 }
 9 const onButtonClick =
10 (status) = >{
11     let action = actions[status]|| actions['default'],
12     logName = action[0],
13     pageName = action[1] 
14     sendLog(logName) 
15     jumpTo(pageName)
16 }

View Code

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

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

 1 const actions = new Map([ 
 2     [1, ['processing', 'IndexPage']], 
 3     [2, ['fail', 'FailPage']], 
 4     [3, ['fail', 'FailPage']], 
 5     [4, ['success', 'SuccessPage']], 
 6     [5, ['cancel', 'CancelPage']], 
 7     ['default', ['other', 'Index']]]) 
 8 const onButtonClick = (status) => 
 9 {
10     let action = actions.get(status) || actions.get('default') 
11     sendLog(action[0]) 
12     jumpTo(action[1])
13 }

View Code

這樣寫用到了es6裏的Map對象，是否是更爽了？Map對象和Object對象有什麼區別呢？spa

一個對象一般都有本身的原型，因此一個對象總有一個"prototype"鍵。prototype
一個對象的鍵只能是字符串或者Symbols，但一個Map的鍵能夠是任意值。
你能夠經過size屬性很容易地獲得一個Map的鍵值對個數，而對象的鍵值對個數只能手動確認。

咱們須要把問題升級一下，之前按鈕點擊時候只須要判斷status，如今還須要判斷用戶的身份：

 1 const onButtonClick = (status, identity) => 
 2 {
 3     if(identity == 'guest')
 4     {
 5         if(status == 1) { }
 6         else if (status == 2) { }
 7         else if (status == 3) { }
 8         else if (status == 4) { }
 9         else if (status == 5) { }
10         else { }
11     }
12     else if (identity == 'master') 
13     {
14         if(status == 1) { }
15         else if (status == 2) { }
16         else if (status == 3) { }
17         else if (status == 4) { }
18         else if (status == 5) { }
19         else { }
20     }
21 }

View Code

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

原諒我又用了if/else，由於我看到不少人依然在用if/else寫這種大段的邏輯判斷。

從上面的例子咱們能夠看到，當你的邏輯升級爲二元判斷時，你的判斷量會加倍，你的代碼量也會加倍，這時怎麼寫更清爽呢？

 1 const actions = new Map([ 
 2     ['guest_1', () => {}], 
 3     ['guest_2', () => {}], 
 4     ['guest_3', () => {}], 
 5     ['guest_4', () => {}], 
 6     ['guest_5', () => {}], 
 7     ['master_1', () => {}], 
 8     ['master_2', () => {}], 
 9     ['master_3', () => {}], 
10     ['master_4', () => {}], 
11     ['master_5', () => {}], 
12     ['default', () => {}], ])
13 
14 /**
15  * 按鈕點擊事件
16  * @param {string} identity 身份標識：guest客態 master主態
17  * @param {number} status 活動狀態：1 開團進行中 2 開團失敗 3 開團成功 4 商品售罄 5 有庫存未開團
18  */
19 const onButtonClick = (identity, status) => 
20 {
21     let action = actions.get(`$ {identity}_${status}`) || actions.get('default') 
22     action.call(this)
23 }

View Code

上述代碼核心邏輯是：把兩個條件拼接成字符串，並經過以條件拼接字符串做爲鍵，以處理函數做爲值的Map對象進行查找並執行，這種寫法在多元條件判斷時候尤爲好用。

固然上述代碼若是用Object對象來實現也是相似的：

1 const actions = {
2     'guest_1' : () => {}, 
3     'guest_2' : () => {}, 
4     //....
5 }
6 const onButtonClick = (identity, status) => {
7     let action = actions[`${identity}_${status}`] || actions['default'] 
8     action.call(this)
9 }

View Code

若是有些同窗以爲把查詢條件拼成字符串有點彆扭，那還有一種方案，就是用Map對象，以Object對象做爲key：

 1 const actions = new Map([ 
 2     [{identity : 'guest', status : 1},() => {}], 
 3     [{identity : 'guest', status : 2},() => {}], 
 4     //...
 5 ]) 
 6 const onButtonClick = (identity, status) => 
 7 {
 8     let action = [...actions].filter(([key, value]) => (key.identity == identity && key.status == status)) 
 9     action.forEach(([key, value]) => value.call(this))
10 }

View Code

是否是又高級了一點點？

這裏也看出來Map與Object的區別，Map能夠用任何類型的數據做爲key。

咱們如今再將難度升級一點點，假如guest狀況下，status1-4的處理邏輯都同樣怎麼辦，最差的狀況是這樣：

1 const actions = new Map([ 
2 [{identity : 'guest', status : 1},() => {}], 
3 [{identity : 'guest', status : 2},() => {}],
4 [{identity : 'guest', status : 3},() => {}],
5 [{identity : 'guest', status : 4},() => {}],
6 [{identity : 'guest', status : 5},() => {}], 
7 //...
8 ])

View Code

好一點的寫法是將處理邏輯函數進行緩存：

 1 const actions = () => 
 2 {
 3     const functionA = () => {}
 4     const functionB = () => {}
 5     return new Map([ 
 6     [{identity : 'guest', status : 1},functionA], 
 7     [{identity : 'guest', status : 2},functionA], 
 8     [{identity : 'guest', status : 3},functionA], 
 9     [{identity : 'guest', status : 4},functionA], 
10     [{identity : 'guest', status : 5},functionB], ])
11 }
12 const onButtonClick = (identity, status) => 
13 {
14     let action = [...actions()].filter(([key, value]) => (key.identity == identity && key.status == status)) 
15     action.forEach(([key, value]) => value.call(this))
16 }

View Code

這樣寫已經能知足平常需求了，但認真一點講，上面重寫了4次functionA仍是有點不爽，假如判斷條件變得特別複雜，好比identity有3種狀態，status有10種狀態，那你須要定義30條處理邏輯，而每每這些邏輯裏面不少都是相同的，這彷佛也是筆者不想接受的，那能夠這樣實現:

 1 const actions = () => 
 2 {
 3     const functionA = () => {}
 4     const functionB = () => {}
 5     return new Map([ 
 6         [/^guest_[1-4]$/, functionA], 
 7         [/^guest_5$/, functionB], 
 8     ])
 9 }
10 const onButtonClick = (identity, status) => 
11 {
12     let action = [...actions()].filter(([key, value]) => (key.test(`${identity}_${status}`))) 
13     action.forEach(([key, value]) => value.call(this))
14 }

View Code

這裏Map的優點更加凸顯，能夠用正則類型做爲key了，這樣就有了無限可能，假如需求變成，凡是guest狀況都要發送一個日誌埋點，不一樣status狀況也須要單獨的邏輯處理，那咱們能夠這樣寫:

 1 const actions = () => 
 2 {
 3     const functionA = () => {}
 4     const functionB = () => {}
 5     const functionC = () => {}
 6     return new Map([ 
 7         [/^guest_[1-4]$/, functionA], 
 8         [/^guest_5$/, functionB], 
 9         [/^guest_.*$/, functionC], 
10     ])
11 }
12 
13 const onButtonClick = (identity, status) => 
14 {
15     let action = [...actions()].filter(([key, value]) => (key.test(`${identity}_${status}`))) 
16     action.forEach(([key, value]) => value.call(this))
17 }