高性能JavaScript 循環語句和流程控制

前言

　　上一篇探討了JavaScript達夫設備對於代碼性能的影響，本文主要探討並且測試各種常見的循環語句的性能以及流程控制中常見的優化。

循環語句

　　眾所周知，常用的循環語句有for、while、do-while以及for-in，forEach。除了for-in和forEach性能略低外，平時我們對前三者的選擇更多的是基於需求而非性能考慮，今天我們就對它們各自的性能做個測試，告訴我們最極端的情況下還能做哪些優化。

　　首先我們來談談為何for-in和forEach會比其他的慢。for-in一般是用在對象屬性名的遍歷上的，由於每次迭代操作會同時搜索實例本身的屬性以及原型鏈上的屬性，所以效率肯定低下；而forEach是基於函數的迭代（需要特別注意的是所有版本的ie都不支持，如果需要可以用JQuery等庫），對每個數組項調用外部方法所帶來的開銷是速度慢的主要原因。

　　接著我們看看每次迭代中for、while以及do-while都做了什麼。

var length = items.length;
for(var i = 0; i < length; i++)
  process(items[i]);

var j = 0;
while(j < length) 
  process(items[j++]);

var k = 0;
do {
  process(items[k++]);
} while(k < length);

　　上面的每個循環中，每次運行循環體時都會產生這樣的操作：

1. 一次控制條件中的數值大小比較（i < length）
2. 一次控制條件結果是否為true的比較（i < length === true）
3. 一次自增操作（i++）
4. 一次數組查找（items[i]）
5. 一次函數調用process(items[i])

　　我們可以通過顛倒數組的順序來提高循環性能：

for(var i = items.length; i--; )
  process(items[i]);

var j = items.length;
while(j--) 
  process(items[j]);

var k = items.length - 1;
do {
  process(items[k]);
} while(k--);

　　本例中使用了倒序循環，並把減法操作整合在循環條件中。現在每個控制條件只是簡單地與0比較。控制條件與true值比較，任何非零數會自動轉換為true，而零值等同於false。實際上，控制條件從兩個比較（迭代數少於總數嗎？它是true嗎？）減少到一次比較（它是true嗎？）。每次迭代從兩次比較減少到一次，進一步提高了循環速度。 

性能測試：

　　那麼事實真的如此嗎？真金不怕浏覽器驗。測試代碼很簡單，針對不同的8種情況封裝了8個函數（不加定時器firefox下無法打印profiles信息，原因不明）：

// init array
var a = [];
var length = 10;
for(var i = 0; i < length; i++)
  a[i] = 1;

function for_in() {
  var sum = 0;
  for(var i in a) 
    sum += a[i];
}

function for_each() {
  var sum = 0;
  a.forEach(function(value, index, array) {
    sum += value;
  });
}

function for_normal() {
  var sum = 0;
  for(var i = 0; i < length; i++)
    sum += a[i];
}

function for_reverse() {
  var sum = 0;
  for(var i = length; i--; )
    sum += a[i];
}

function while_normal() {
  var sum = 0;
  var i = 0;
  while(i < length) 
    sum += a[i++];
}

function while_reverse() {
  var sum = 0;
  var i = length;
  while(i--) 
    sum += a[i];
}

function do_while_normal() {
  var sum = 0;
  var i = 0;
  do {
    sum += a[i++];
  } while(i < length);
}

function do_while_reverse() {
  var sum = 0;
  var i = length - 1;
  do {
    sum += a[i];
  } while(i--);
}


setTimeout(function() {
  console.profile();
  for_in();
  for_each();
  for_normal();　　
  for_reverse();
  while_normal();
  while_reverse();
  do_while_normal();
  do_while_reverse();
  console.profileEnd();
}, 1000);

　　當數組長度為100時，我們發現firefox下的結果確實和預料的相似：for-each和for-in效率低下，倒序比正序效率略微提升。（chrome下的profiles由於時間太短不顯示）

　　當數據量達到100w時，firefox和chrome下的結果都如人所願，但是也略微有所不同。ff下的for-in表現地比for-each好，而chrome下for-in表現糟糕，直接提出了警告。而倒序迭代雖然性能略微有所提升，但是提升的不是很多，且降低了代碼閱讀性。

 小結：

1. 倒序迭代確實能略微提升代碼性能，但是犧牲了代碼可讀性，除非追求極端性能優化情況下不然沒必要用
2. 遍歷數組能用普通的循環就不要用for-in和for-each

條件語句

　　常見的條件語句有if-else和switch-case，那麼什麼時候用if-else，什麼時候用switch-case語句呢？

　　我們先來看個簡單的if-else語句的代碼：

if (value == 0){
    return result0;
} else if (value == 1){
    return result1;
} else if (value == 2){
    return result2;
} else if (value == 3){
    return result3;
} else if (value == 4){
    return result4;
} else if (value == 5){
    return result5;
} else if (value == 6){
    return result6;
} else if (value == 7){
    return result7;
} else if (value == 8){
    return result8;
} else if (value == 9){
    return result9;
} else {
    return result10;
}

　　最壞的情況下（value=10）我們可能要做10次判斷才能返回正確的結果，那麼我們怎麼優化這段代碼呢？一個顯而易見的優化策略是將最可能的取值提前判斷，比如value最可能等於5或者10，那麼將這兩條判斷提前。但是通常情況下我們並不知道（最可能的選擇），這時我們可以采取二叉樹查找策略進行性能優化。

if (value < 6){
    if (value < 3){
        if (value == 0){
            return result0;
        } else if (value == 1){
            return result1;
        } else {
            return result2;
        }
    } else {
        if (value == 3){
            return result3;
        } else if (value == 4){
            return result4;
        } else {
            return result5;
        }
    }
} else {
    if (value < 8){
        if (value == 6){
            return result6;
        } else {
            return result7;
        }
    } else {
        if (value == 8){
            return result8;
        } else if (value == 9){
            return result9;
        } else {
            return result10;
        }
    }
}

　　這樣優化後我們最多進行4次判斷即可，大大提高了代碼的性能。這樣的優化思想有點類似二分查找，和二分查找相似的是，只有value值是連續的數字時才能進行這樣的優化。但是代碼這樣寫的話不利於維護，如果要增加一個條件，或者多個條件，就要重寫很多代碼，這時switch-case語句就有了用武之地。

　　將以上代碼用switch-case語句重寫：

switch(value){
    case 0:
        return result0;
    case 1:
        return result1;
    case 2:
        return result2;
    case 3:
        return result3;
    case 4:
        return result4;
    case 5:
        return result5;
    case 6:
        return result6;
    case 7:
        return result7;
    case 8:
        return result8;
    case 9:
        return result9;
    default:
        return result10;
}

　　swtich-case語句讓代碼顯得可讀性更強，而且swtich-case語句還有一個好處是如果多個value值返回同一個結果，就不用重寫return那部分的代碼。一般來說，當case數達到一定數量時，swtich-case語句的效率是比if-else高的，因為switch-case采用了branch table（分支表）索引來進行優化，當然各浏覽器的優化程度也不一樣。

　　除了if-else和swtich-case外，我們還可以采用查找表。

var results = [result0, result1, result2, result3, result4, result5, result6, result7, result8, result9, result10];

//return the correct result
return results[value];

　　當數據量很大的時候，查找表的效率通常要比if-else語句和swtich-case語句高，查找表能用數字和字符串作為索引，而如果是字符串的情況下，最好用對象來代替數組。當然查找表的使用是有局限性的，每個case對應的結果只能是一個取值而不能是一系列的操作。 

小結：

1. 當只有兩個case或者case的value取值是一段連續的數字的時候，我們可以選擇if-else語句
2. 當有3~10個case數並且case的value取值非線性的時候，我們可以選擇switch-case語句
3. 當case數達到10個以上並且每次的結果只是一個取值而不是額外的JavaScript語句的時候，我們可以選擇查找表　

高性能JavaScript編程(高清PDF原版)及中英文對照版 PDF  http://www.linuxidc.com/Linux/2015-08/121418.htm