日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關(guān)咨詢
選擇下列產(chǎn)品馬上在線溝通
服務(wù)時間：8:30-17:00
你可能遇到了下面的問題
關(guān)閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
寫好JS條件語句的5條守則

在用 JavaScript 工作時，我們經(jīng)常和條件語句打交道，這里有5條讓你寫出更好/干凈的條件語句的建議。

我們提供的服務(wù)有：網(wǎng)站建設(shè)、做網(wǎng)站、微信公眾號開發(fā)、網(wǎng)站優(yōu)化、網(wǎng)站認證、衡山ssl等。為千余家企事業(yè)單位解決了網(wǎng)站和推廣的問題。提供周到的售前咨詢和貼心的售后服務(wù)，是有科學(xué)管理、有技術(shù)的衡山網(wǎng)站制作公司

目錄：

  • 多重判斷時使用 Array.includes
  • 更少的嵌套，盡早 return
  • 使用默認參數(shù)和解構(gòu)
  • 傾向于遍歷對象而不是 Switch 語句
  • 對 所有/部分 判斷使用 Array.every & Array.some
  • 總結(jié)

1. 多重判斷時使用 Array.includes

讓我們看一下下面這個例子:

 
 
 
 
    
  
  
  
  
  1. // condition 
    2. 
  
  
  
  
  2. function test(fruit) { 
    3. 
  
  
  
  
  3.   if (fruit == 'apple' || fruit == 'strawberry') { 
    4. 
  
  
  
  
  4.     console.log('red'); 
    5. 
  
  
  
  
  5.   } 
    6. 
  
  
  
  
  6. } 
    7.

第一眼，上面這個例子看起來沒問題。如果我們有更多名字叫 cherry 和 cranberries 的紅色水果呢?我們準備用更多的 || 來拓展條件語句嗎?

我們可以用 Array.includes (Array.includes)重寫條件語句。

 
 
 
 
    
  
  
  
  
  1. function test(fruit) { 
    2. 
  
  
  
  
  2.   const redFruits = ['apple', 'strawberry', 'cherry', 'cranberries']; 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4.   if (redFruits.includes(fruit)) { 
    5. 
  
  
  
  
  5.     console.log('red'); 
    6. 
  
  
  
  
  6.   } 
    7. 
  
  
  
  
  7. } 
    8.

我們把紅色的水果(red fruits)這一判斷條件提取到一個數(shù)組。這樣一來，代碼看起來更整潔。

2. 更少的嵌套，盡早 Return

讓我們拓展上一個例子讓它包含兩個條件。

  • 如果沒有傳入?yún)?shù) fruit，拋出錯誤
  • 接受 quantity 參數(shù)，并且在 quantity 大于 10 時打印出來
 
 
 
 
    
  
  
  
  
  1. function test(fruit, quantity) { 
    2. 
  
  
  
  
  2.   const redFruits = ['apple', 'strawberry', 'cherry', 'cranberries']; 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4.   // 條件 1: fruit 必須有值 
    5. 
  
  
  
  
  5.   if (fruit) { 
    6. 
  
  
  
  
  6.     // 條件 2: 必須是red的 
    7. 
  
  
  
  
  7.     if (redFruits.includes(fruit)) { 
    8. 
  
  
  
  
  8.       console.log('red'); 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10.       // 條件 3: quantity大于10 
    11. 
  
  
  
  
  11.       if (quantity > 10) { 
    12. 
  
  
  
  
  12.         console.log('big quantity'); 
    13. 
  
  
  
  
  13.       } 
    14. 
  
  
  
  
  14.     } 
    15. 
  
  
  
  
  15.   } else { 
    16. 
  
  
  
  
  16.     throw new Error('No fruit!'); 
    17. 
  
  
  
  
  17.   } 
    18. 
  
  
  
  
  18. } 
    19. 
  
  
  
  
  19.  
    20. 
  
  
  
  
  20. // 測試結(jié)果 
    21. 
  
  
  
  
  21. test(null); // error: No fruits 
    22. 
  
  
  
  
  22. test('apple'); // print: red 
    23. 
  
  
  
  
  23. test('apple', 20); // print: red, big quantity 
    24.

在上面的代碼, 我們有:

  • 1個 if/else 語句篩選出無效的語句
  • 3層if嵌套語句 (條件 1, 2 & 3)

我個人遵循的規(guī)則一般是在發(fā)現(xiàn)無效條件時，盡早Return。

 
 
 
 
    
  
  
  
  
  1. /_ 當發(fā)現(xiàn)無效語句時，盡早Return _/ 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. function test(fruit, quantity) { 
    4. 
  
  
  
  
  4.   const redFruits = ['apple', 'strawberry', 'cherry', 'cranberries']; 
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6.   // 條件 1: 盡早拋出錯誤 
    7. 
  
  
  
  
  7.   if (!fruit) throw new Error('No fruit!'); 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9.   // 條件 2: 必須是紅色的 
    10. 
  
  
  
  
  10.   if (redFruits.includes(fruit)) { 
    11. 
  
  
  
  
  11.     console.log('red'); 
    12. 
  
  
  
  
  12.  
    13. 
  
  
  
  
  13.     // 條件 3: 必須是大質(zhì)量的 
    14. 
  
  
  
  
  14.     if (quantity > 10) { 
    15. 
  
  
  
  
  15.       console.log('big quantity'); 
    16. 
  
  
  
  
  16.     } 
    17. 
  
  
  
  
  17.   } 
    18. 
  
  
  
  
  18. } 
    19.

這樣一來，我們少了一層嵌套語句。這種編碼風(fēng)格非常好，尤其是當你有很長的if語句的時候(想象你需要滾動到最底層才知道還有else語句，這并不酷)

我們可以通過 倒置判斷條件 & 盡早return 進一步減少if嵌套?？聪旅嫖覀兪窃趺刺幚砼袛?條件2 的:

 
 
 
 
    
  
  
  
  
  1. /_ 當發(fā)現(xiàn)無效語句時，盡早Return _/ 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. function test(fruit, quantity) { 
    4. 
  
  
  
  
  4.   const redFruits = ['apple', 'strawberry', 'cherry', 'cranberries']; 
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6.   // 條件 1: 盡早拋出錯誤 
    7. 
  
  
  
  
  7.   if (!fruit) throw new Error('No fruit!'); 
    8. 
  
  
  
  
  8.   // 條件 2: 當水果不是紅色時停止繼續(xù)執(zhí)行 
    9. 
  
  
  
  
  9.   if (!redFruits.includes(fruit)) return;  
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11.   console.log('red'); 
    12. 
  
  
  
  
  12.  
    13. 
  
  
  
  
  13.   // 條件 3: 必須是大質(zhì)量的 
    14. 
  
  
  
  
  14.   if (quantity > 10) { 
    15. 
  
  
  
  
  15.     console.log('big quantity'); 
    16. 
  
  
  
  
  16.   } 
    17. 
  
  
  
  
  17. } 
    18.

通過倒置判斷條件2，我們的代碼避免了嵌套語句。這個技巧在我們需要進行很長的邏輯判斷時是非常有用的，特別是我們希望能夠在條件不滿足時能夠停止下來進行處理。

而且這么做并不困難。問問自己，這個版本(沒有嵌套)是不是比之前的(兩層條件嵌套)更好，可讀性更高?

但對于我，我會保留先前的版本(包含兩層嵌套)。這是因為:

  • 代碼比較短且直接，包含if嵌套的更清晰
  • 倒置判斷條件可能加重思考的負擔(dān)(增加認知載荷)

因此，應(yīng)當盡力減少嵌套和盡早return，但不要過度。如果你感興趣的話，可以看一下關(guān)于這個話題的一篇文章和 StackOverflow 上的討論。

  • Avoid Else, Return Early by Tim Oxley
  • StackOverflow discussion on if/else coding style

3. 使用默認參數(shù)和解構(gòu)

我猜下面的代碼你可能會熟悉，在JavaScript中我們總是需要檢查 null / undefined的值和指定默認值：

 
 
 
 
    
  
  
  
  
  1. function test(fruit, quantity) { 
    2. 
  
  
  
  
  2.   if (!fruit) return; 
    3. 
  
  
  
  
  3.   // 如果 quantity 參數(shù)沒有傳入，設(shè)置默認值為 1 
    4. 
  
  
  
  
  4.   const q = quantity || 1;  
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6.   console.log(`We have ${q} ${fruit}!`); 
    7. 
  
  
  
  
  7. } 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9. //test results 
    10. 
  
  
  
  
  10. test('banana'); // We have 1 banana! 
    11. 
  
  
  
  
  11. test('apple', 2); // We have 2 apple! 
    12.

實際上，我們可以通過聲明 默認函數(shù)參數(shù) 來消除變量 q。

 
 
 
 
    
  
  
  
  
  1. function test(fruit, quantity = 1) { 
    2. 
  
  
  
  
  2.   // 如果 quantity 參數(shù)沒有傳入，設(shè)置默認值為 1 
    3. 
  
  
  
  
  3.   if (!fruit) return; 
    4. 
  
  
  
  
  4.   console.log(`We have ${quantity} ${fruit}!`); 
    5. 
  
  
  
  
  5. } 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. //test results 
    8. 
  
  
  
  
  8. test('banana'); // We have 1 banana! 
    9. 
  
  
  
  
  9. test('apple', 2); // We have 2 apple! 
    10.

這更加直觀，不是嗎?注意，每個聲明都有自己的默認參數(shù).

例如，我們也能給fruit分配默認值:function test(fruit = 'unknown', quantity = 1)。

如果fruit是一個object會怎么樣?我們能分配一個默認參數(shù)嗎?

 
 
 
 
    
  
  
  
  
  1. function test(fruit) {  
    2. 
  
  
  
  
  2.   // 當值存在時打印 fruit 的值 
    3. 
  
  
  
  
  3.   if (fruit && fruit.name)  { 
    4. 
  
  
  
  
  4.     console.log (fruit.name); 
    5. 
  
  
  
  
  5.   } else { 
    6. 
  
  
  
  
  6.     console.log('unknown'); 
    7. 
  
  
  
  
  7.   } 
    8. 
  
  
  
  
  8. } 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10. //test results 
    11. 
  
  
  
  
  11. test(undefined); // unknown 
    12. 
  
  
  
  
  12. test({ }); // unknown 
    13. 
  
  
  
  
  13. test({ name: 'apple', color: 'red' }); // apple 
    14.

看上面這個例子，我們想打印 fruit 對象中可能存在的 name 屬性。否則我們將打印unknown。我們可以通過默認參數(shù)以及解構(gòu)從而避免判斷條件 fruit && fruit.name

 
 
 
 
    
  
  
  
  
  1. // 解構(gòu) - 僅僅獲取 name 屬性 
    2. 
  
  
  
  
  2. // 為其賦默認值為空對象 
    3. 
  
  
  
  
  3. function test({name} = {}) { 
    4. 
  
  
  
  
  4.   console.log (name || 'unknown'); 
    5. 
  
  
  
  
  5. } 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. // test results 
    8. 
  
  
  
  
  8. test(undefined); // unknown 
    9. 
  
  
  
  
  9. test({ }); // unknown 
    10. 
  
  
  
  
  10. test({ name: 'apple', color: 'red' }); // apple 
    11.

由于我們只需要 name 屬性，我們可以用 {name} 解構(gòu)出參數(shù)，然后我們就能使用變量 name 代替 fruit.name。

我們也需要聲明空對象 {} 作為默認值。如果我們不這么做，當執(zhí)行 test(undefined) 時，你將得到一個無法對 undefined 或 null 解構(gòu)的的錯誤。因為在 undefined 中沒有 name 屬性。

如果你不介意使用第三方庫，這有一些方式減少null的檢查:

  • 使用 Lodash get函數(shù)
  • 使用Facebook開源的idx庫(with Babeljs)

這是一個使用Lodash的例子：

 
 
 
 
    
  
  
  
  
  1. function test(fruit) { 
    2. 
  
  
  
  
  2.   // 獲取屬性名，如果屬性名不可用，賦默認值為 unknown 
    3. 
  
  
  
  
  3.   console.log(__.get(fruit, 'name', 'unknown');  
    4. 
  
  
  
  
  4. } 
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6. // test results 
    7. 
  
  
  
  
  7. test(undefined); // unknown 
    8. 
  
  
  
  
  8. test({ }); // unknown 
    9. 
  
  
  
  
  9. test({ name: 'apple', color: 'red' }); // apple 
    10.

你可以在jsbin運行demo代碼。除此之外，如果你是函數(shù)式編程的粉絲，你可能選擇使用 Lodash fp，Lodash的函數(shù)式版本(方法變更為get或者getOr)。

4. 傾向于對象遍歷而不是Switch語句

讓我們看下面這個例子，我們想根據(jù) color 打印出水果：

 
 
 
 
    
  
  
  
  
  1. function test(color) { 
    2. 
  
  
  
  
  2.   // 使用條件語句來尋找對應(yīng)顏色的水果 
    3. 
  
  
  
  
  3.   switch (color) { 
    4. 
  
  
  
  
  4.     case 'red': 
    5. 
  
  
  
  
  5.       return ['apple', 'strawberry']; 
    6. 
  
  
  
  
  6.     case 'yellow': 
    7. 
  
  
  
  
  7.       return ['banana', 'pineapple']; 
    8. 
  
  
  
  
  8.     case 'purple': 
    9. 
  
  
  
  
  9.       return ['grape', 'plum']; 
    10. 
  
  
  
  
  10.     default: 
    11. 
  
  
  
  
  11.       return []; 
    12. 
  
  
  
  
  12.   } 
    13. 
  
  
  
  
  13. } 
    14. 
  
  
  
  
  14.  
    15. 
  
  
  
  
  15. // test results 
    16. 
  
  
  
  
  16. test(null); // [] 
    17. 
  
  
  
  
  17. test('yellow'); // ['banana', 'pineapple'] 
    18.

上面的代碼看起來沒有錯誤，但是我找到了一些累贅。用對象遍歷實現(xiàn)相同的結(jié)果，語法看起來更簡潔：

 
 
 
 
    
  
  
  
  
  1. const fruitColor = { 
    2. 
  
  
  
  
  2.   red: ['apple', 'strawberry'], 
    3. 
  
  
  
  
  3.   yellow: ['banana', 'pineapple'], 
    4. 
  
  
  
  
  4.   purple: ['grape', 'plum'] 
    5. 
  
  
  
  
  5. }; 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. function test(color) { 
    8. 
  
  
  
  
  8.   return fruitColor[color] || []; 
    9. 
  
  
  
  
  9. } 
    10.

或者你也可以使用 Map實現(xiàn)相同的結(jié)果：

 
 
 
 
    
  
  
  
  
  1.   const fruitColor = new Map() 
    2. 
  
  
  
  
  2.     .set('red', ['apple', 'strawberry']) 
    3. 
  
  
  
  
  3.     .set('yellow', ['banana', 'pineapple']) 
    4. 
  
  
  
  
  4.     .set('purple', ['grape', 'plum']); 
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6. function test(color) { 
    7. 
  
  
  
  
  7.   return fruitColor.get(color) || []; 
    8. 
  
  
  
  
  8. } 
    9.

Map是一種在 ES2015 規(guī)范之后實現(xiàn)的對象類型，允許你存儲 key 和 value 的值。

但我們是否應(yīng)當禁止switch語句的使用呢?答案是不要限制你自己。從個人來說，我會盡可能的使用對象遍歷，但我并不嚴格遵守它，而是使用對當前的場景更有意義的方式。

Todd Motto有一篇關(guān)于 switch 語句對比對象遍歷的更深入的文章，你可以在這個地方閱讀

TL;DR; 重構(gòu)語法

在上面的例子，我們能夠用Array.filter 重構(gòu)我們的代碼，實現(xiàn)相同的效果。

 
 
 
 
    
  
  
  
  
  1.  const fruits = [ 
    2. 
  
  
  
  
  2.     { name: 'apple', color: 'red' },  
    3. 
  
  
  
  
  3.     { name: 'strawberry', color: 'red' },  
    4. 
  
  
  
  
  4.     { name: 'banana', color: 'yellow' },  
    5. 
  
  
  
  
  5.     { name: 'pineapple', color: 'yellow' },  
    6. 
  
  
  
  
  6.     { name: 'grape', color: 'purple' },  
    7. 
  
  
  
  
  7.     { name: 'plum', color: 'purple' } 
    8. 
  
  
  
  
  8. ]; 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10. function test(color) { 
    11. 
  
  
  
  
  11.   return fruits.filter(f => f.color == color); 
    12. 
  
  
  
  
  12. } 
    13.

有著不止一種方法能夠?qū)崿F(xiàn)相同的結(jié)果，我們以上展示了 4 種。

5. 對所有/部分 判斷使用Array.every & Array.some

這最后一個建議更多是關(guān)于利用 JavaScript Array 的內(nèi)置方法來減少代碼行數(shù)?？聪旅娴拇a，我們想要檢查是否所有水果都是紅色：

 
 
 
 
    
  
  
  
  
  1. const fruits = [ 
    2. 
  
  
  
  
  2.     { name: 'apple', color: 'red' }, 
    3. 
  
  
  
  
  3.     { name: 'banana', color: 'yellow' }, 
    4. 
  
  
  
  
  4.     { name: 'grape', color: 'purple' } 
    5. 
  
  
  
  
  5.   ]; 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. function test() { 
    8. 
  
  
  
  
  8.   let isAllRed = true; 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10.   // 條件：所有水果都是紅色 
    11. 
  
  
  
  
  11.   for (let f of fruits) { 
    12. 
  
  
  
  
  12.     if (!isAllRed) break; 
    13. 
  
  
  
  
  13.     isAllRed = (f.color == 'red'); 
    14. 
  
  
  
  
  14.   } 
    15. 
  
  
  
  
  15.  
    16. 
  
  
  
  
  16.   console.log(isAllRed); // false 
    17. 
  
  
  
  
  17. } 
    18.

代碼那么長!我們可以通過 Array.every減少代碼行數(shù)：

 
 
 
 
    
  
  
  
  
  1. const fruits = [ 
    2. 
  
  
  
  
  2.     { name: 'apple', color: 'red' }, 
    3. 
  
  
  
  
  3.     { name: 'banana', color: 'yellow' }, 
    4. 
  
  
  
  
  4.     { name: 'grape', color: 'purple' } 
    5. 
  
  
  
  
  5.   ]; 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. function test() { 
    8. 
  
  
  
  
  8.   const isAllRed = fruits.every(f => f.color == 'red'); 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10.   console.log(isAllRed); // false 
    11. 
  
  
  
  
  11. } 
    12.

現(xiàn)在更簡潔了，不是嗎?相同的方式，如果我們想測試是否存在紅色的水果，我們可以使用 Array.some 一行代碼實現(xiàn)。

 
 
 
 
    
  
  
  
  
  1. const fruits = [ 
    2. 
  
  
  
  
  2.     { name: 'apple', color: 'red' }, 
    3. 
  
  
  
  
  3.     { name: 'banana', color: 'yellow' }, 
    4. 
  
  
  
  
  4.     { name: 'grape', color: 'purple' } 
    5. 
  
  
  
  
  5. ]; 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. function test() { 
    8. 
  
  
  
  
  8.   // 條件：任何一個水果是紅色 
    9. 
  
  
  
  
  9.   const isAnyRed = fruits.some(f => f.color == 'red'); 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11.   console.log(isAnyRed); // true 
    12. 
  
  
  
  
  12. } 
    13.

6. 總結(jié)

讓我們一起生產(chǎn)更多可讀性高的代碼。我希望你能從這篇文章學(xué)到東西。

這就是所有的內(nèi)容。編碼快樂!


文章題目：寫好JS條件語句的5條守則
當前地址：http://www.5511xx.com/article/dpojdjj.html