高性能JavaScript 循环语句和流程控制

循环语句

众所周知，常用的循环语句有for、while、do-while以及for-in，forEach。除了for-in和forEach性能略低外，平时我们对前三者的选择更多的是基于需求而非性能考虑，今天我们就对它们各自的性能做个测试，告诉我们最极端的情况下还能做哪些优化。

首先我们来谈谈为何for-in和forEach会比其他的慢。for-in一般是用在对象属性名的遍历上的，由于每次迭代操作会同时搜索实例本身的属性以及原型链上的属性，所以效率肯定低下；而forEach是基于函数的迭代（需要特别注意的是所有版本的ie都不支持，如果需要可以用JQuery等库），对每个数组项调用外部方法所带来的开销是速度慢的主要原因。

接着我们看看每次迭代中for、while以及do-while都做了什么。

1. var length = items.length; 
2. for(var i = 0; i < length; i++) 
3.     process(items[i]); 
4. 
   
5. var j = 0; 
6. while(j < length)
7.     process(items[j++]); 
8. 
   
9. var k = 0; 
10. do { 
11.     process(items[k++]); 
12. }while(k < length);

上面的每个循环中，每次运行循环体时都会产生这样的操作：

• 一次控制条件中的数值大小比较（i < length）

• 一次控制条件结果是否为true的比较（i < length === true）
• 一次自增操作（i++）
• 一次数组查找（items[i]）
• 一次函数调用process(items[i])

我们可以通过颠倒数组的顺序来提高循环性能：

1. for(var i = items.length; i--; ) 
2.     process(items[i]); 
3. var j = items.length; 
4. 
   
5. while(j--)
6.     process(items[j]); 
7. 
   
8. var k = items.length - 1; 
9. do { 
10.     process(items[k]); 
11. } while(k--);

本例中使用了倒序循环，并把减法操作整合在循环条件中。现在每个控制条件只是简单地与0比较。控制条件与true值比较，任何非零数会自动转换为true，而零值等同于false。实际上，控制条件从两个比较（迭代数少于总数吗？它是true吗？）减少到一次比较（它是true吗？）。每次迭代从两次比较减少到一次，进一步提高了循环速度。

性能测试：

那么事实真的如此吗？真金不怕浏览器验。测试代码很简单，针对不同的8种情况封装了8个函数（不加定时器firefox下无法打印profiles信息，原因不明）：

1. //init array 
2. var a = []; 
3. var length = 10; 
4. for(var i = 0; i < length; i++) 
5.     a[i] = 1; 
6. function for_in() { 
7.     var sum = 0; 
8.     for(var i in a) 
9.         sum += a[i]; 
10. }
11. function for_each() { 
12.    var sum = 0; 
13.     a.forEach(function(value, index, array) { 
14.         sum += value; }); 
15. } 
16. 
    
17. function for_normal() { 
18.     var sum = 0; 
19.     for(var i = 0; i < length; i++) 
20.         sum += a[i]; 
21. } 
22. 
    
23. function for_reverse() { 
24.     var sum = 0; 
25.     for(var i = length; i--; ) 
26.     sum += a[i]; 
27. }
28. 
    
29. function while_normal() { 
30.     var sum = 0; 
31.     var i = 0; 
32.     while(i < length) 
33.         sum += a[i++]; 
34. } 
35. 
    
36. function while_reverse() { 
37.     var sum = 0; 
38.     var i = length; 
39.     while(i--) 
40.         sum += a[i]; 
41. } 
42. 
    
43. function do_while_normal() {
44.     var sum = 0; 
45.     var i = 0; 
46.     do { 
47.         sum += a[i++]; 
48.     } 
49.     while(i < length);
50. }
51.  
52. function do_while_reverse() {
53.     var sum = 0;
54.     var i = length - 1; 
55.     do {  
56.         sum += a[i];
57.     }while(i--);
58. }
59.  
60. setTimeout(function() { 
61.     console.profile(); 
62.     for_in();
63.     for_each(); 
64.     for_normal();　　 
65.     for_reverse(); 
66.     while_normal();
67.     while_reverse(); 
68.     do_while_normal(); 
69.     do_while_reverse(); 
70.     console.profileEnd(); 
71. }, 1000);

当数组长度为100时，我们发现firefox下的结果确实和预料的相似：for-each和for-in效率低下，倒序比正序效率略微提升。（chrome下的profiles由于时间太短不显示）

当数据量达到100w时，firefox和chrome下的结果都如人所愿，但是也略微有所不同。ff下的for-in表现地比for-each好，而chrome下for-in表现糟糕，直接提出了警告。而倒序迭代虽然性能略微有所提升，但是提升的不是很多，且降低了代码阅读性。

小结：

• 倒序迭代确实能略微提升代码性能，但是牺牲了代码可读性，除非追求极端性能优化情况下不然没必要用
• 遍历数组能用普通的循环就不要用for-in和for-each

条件语句

常见的条件语句有if-else和switch-case，那么什么时候用if-else，什么时候用switch-case语句呢？

我们先来看个简单的if-else语句的代码：

1. if (value == 0){
2.     return result0; 
3. } 
4. else if (value == 1){ 
5.     return result1; 
6. } 
7. else if (value == 2){ 
8.     return result2; 
9. } 
10. else if (value == 3){ 
11.     return result3;
12. } 
13. else if (value == 4){
14.     return result4; 
15. } 
16. else if (value == 5){ 
17.     return result5; 
18. } 
19. else if (value == 6){ 
20.     return result6; 
21. } 
22. else if (value == 7){ 
23.     return result7; 
24. } 
25. else if (value == 8){
26.     return result8; 
27. } 
28. else if (value == 9){ 
29.     return result9; 
30. } else { 
31.     return result10; 
32. }

最坏的情况下（value=10）我们可能要做10次判断才能返回正确的结果，那么我们怎么优化这段代码呢？一个显而易见的优化策略是将最可能的取值提前判断，比如value最可能等于5或者10，那么将这两条判断提前。但是通常情况下我们并不知道（最可能的选择），这时我们可以采取二叉树查找策略进行性能优化。

1. if (value < 6){ 
2.     if (value < 3){ 
3.         if (value == 0){ 
4.             return result0; 
5.         } 
6.         else if (value == 1){ 
7.             return result1; 
8.         }
9.         else { 
10.             return result2; 
11.         } 
12.     }  
13.     else { 
14.         if (value == 3){ 
15.             return result3; 
16.         } 
17.         else if (value == 4){
18.             return result4; 
19.         }
20.         else { 
21.             return result5; 
22.         } 
23.     } 
24. } 
25. else { 
26.     if (value < 8){
27.         if (value == 6){ 
28.             return result6; 
29.         } 
30.         else { 
31.             return result7; 
32.         } 
33.     } 
34.     else { 
35.         if (value == 8){ 
36.             return result8; 
37.         } 
38.         else if (value == 9){ 
39.             return result9; 
40.         } 
41.         else { 
42.             return result10;
43.         } 
44.     } 
45. }

swtich-case语句让代码显得可读性更强，而且swtich-case语句还有一个好处是如果多个value值返回同一个结果，就不用重写return那部分的代码。一般来说，当case数达到一定数量时，swtich-case语句的效率是比if-else高的，因为switch-case采用了branch table（分支表）索引来进行优化，当然各浏览器的优化程度也不一样。

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

1. var results = [result0, result1, result2, result3, result4, result5, result6, result7, result8, result9, result10]; 
2. 
   
3. //return the correct result 
4. return results[value];

小结：

• 当只有两个case或者case的value取值是一段连续的数字的时候，我们可以选择if-else语句
• 当有3~10个case数并且case的value取值非线性的时候，我们可以选择switch-case语句
• 当case数达到10个以上并且每次的结果只是一个取值而不是额外的JavaScript语句的时候，我们可以选择查找表

作者： GD_SeHun 
链接：http://www.imooc.com/article/3657
来源：慕课网