Javascript优化原则

比如：
代码

   1. function sum() { 
   2.     var r = 0; 
   3.     for (var i = 0; i < arguments.length; i++) { 
   4.         r += arguments[i]; 
   5.     } 
   6.     return r; 
   7. } 

这个sum通常调用的时候个数是较少的，我们希望改进它在参数较少时的性能。如果改成：
代码

   1. function sum() { 
   2.     switch (arguments.length) { 
   3.         case 1: return arguments[0]; 
   4.         case 2: return arguments[0] + arguments[1]; 
   5.         case 3: return arguments[0] + arguments[1] + arguments[2]; 
   6.         case 4: return arguments[0] + arguments[1] + arguments[2] + arguments[3]; 
   7.         default: 
   8.             var r = 0; 
   9.             for (var i = 0; i < arguments.length; i++) { 
  10.                 r += arguments[i]; 
  11.             } 
  12.             return r; 
  13.     } 
  14. } 

其实并不会有多少提高，但是如果改成：
代码

   1. function sum(a, b, c, d, e, f, g) { 
   2.     var r = a ? b ? c ? d ? e ? f ? a + b + c + d + e + f : a + b + c + d + e : a + b + c + d : a + b + c : a + b : a : 0; 
   3.     if (g === undefined) return r; 
   4.     for (var i = 6; i < arguments.length; i++) { 
   5.         r += arguments[i]; 
   6.     } 
   7.     return r; 
   8. } 

就会提高很多（至少快1倍）。

最后是第五原则，也往往是真实应用中最重要的性能障碍，那就是尽量减少不必要的对象创建。

本身创建对象是有一定的代价的，但是这个代价其实并不大。最根本的问题是由于JScript愚蠢之极的垃圾回收调度算法，导致随着对象个数的增加，性能严重下降（据微软的人自己说复杂度是O(n^2)）。

比如我们常见的字符串拼接问题，经过我的测试验证，单纯的多次创建字符串对象其实根本不是性能差的原因。要命的是在对象创建期间的无谓的垃圾回收的开销。而Array.join的方式，不会创建中间字符串对象，因此就减少了那该死的垃圾回收的开销。

因此，如果我们能把大规模对象创建转化为单一语句，则其性能会得到极大的提高！例如通过构造代码然后eval——实际上PIES项目中正在根据这个想法来做一个专门的大规模对象产生器……

好了上面就是偶总结的JS优化五大原则。

除了这些原则以外，还有一些特殊情况，如DOM的遍历，以后有时间再做讨论。