JavaScript陷阱太多，因此我们得步步为营，下面是一些常见的影响性能的陷阱。1.避免使用eval或者Function构造函数
运行缓慢的代码：
function addMethod ( object , property , code ) {
object [ property ] = new Function ( code ) ;
}
addMethod ( myObj , 'methodName' , 'this.localVar=foo' ) ;
运行更快的代码：
function addMethod ( object , property , func ) {
object [ property ] = func ;
}
addMethod ( myObj , 'methodName' , function ( ) { 'this.localVar=foo' ; } ) ;
2.避免使用with
运行缓慢的代码：
with ( test . object ) {
foo = 'Value of foo property of object' ;
bar = 'Value of bar property of object' ;
}
运行更快的代码：
var myObj = test . object ;
myObj . foo = 'Value of foo property of object' ;
myObj . bar = 'Value of bar property of object' ;
3.不要在性能要求关键的函数中使用try-catch-finally
运行缓慢的代码：
var object = [ 'foo' , 'bar' ] , i ;
for ( i = 0 ; i < object . length ; i ++ ) {
try {
// do something that throws an exception
} catch ( e ) {
// handle exception
}
}
运行更快的代码：
var object = [ 'foo' , 'bar' ] , i ;
try {
for ( i = 0 ; i < object . length ; i ++ ) {
// do something
}
} catch ( e ) {
// handle exception
}
4.避免使用全局变量
运行缓慢的代码：
var i ,
str = '' ;
function globalScope ( ) {
for ( i = 0 ; i < 100 ; i ++ ) {
str += i ; // here we reference i and str in global scope which is slow
}
}
globalScope ( ) ;
运行更快的代码：
function localScope ( ) {
var i ,
str = '' ;
for ( i = 0 ; i < 100 ; i ++ ) {
str += i ; // i and str in local scope which is faster
}
}
localScope ( ) ;
5.避免在性能要求关键的函数中使用for-in
运行缓慢的代码：
var sum = 0 ;
for ( var i in arr ) {
sum += arr [ i ] ;
}
运行更快的代码：
var sum = 0 ;
for ( var i = 0 , len = arr . length ; i < len ; i ++ ) {
sum += arr [ i ] ;
}
6.使用字符串累加计算风格
运行缓慢的代码：
运行更快的代码：
7.原操作会比函数调用快
var min = Math . min ( a , b ) ;
arr . push ( val ) ;
运行更快的代码：
var min = a < b ? a : b ;
arr [ arr . length ] = val ;
8.设置setTimeout() 和 setInterval() 时传递函数名而不是字符串
运行缓慢的代码：
setInterval ( 'doSomethingPeriodically()' , 1000 ) ;
setTimeOut ( 'doSomethingAfterFiveSeconds()' , 5000 ) ;
运行更快的代码：
setInterval ( doSomethingPeriodically , 1000 ) ;
setTimeOut ( doSomethingAfterFiveSeconds , 5000 ) ;
9.避免在对象中使用不需要的DOM引用
不要这么做：
var car = new Object ( ) ;
car . color = "red" ;
car . type = "sedan"
更好的一种形式：
var car = {
color : "red" ;
type : "sedan"
}
10.最清晰的目标速度，最小化作用域链
低效率方法：
一种高效形式：
var url = window . location . href ;
11.试着在脚本中少使用注释，避免使用长变量名
不建议的形式：
function someFunction ( )
{
var person_full_name = "somename" ; /* stores the full name*/
}
更好的写法：
function someFunction ( )
{
var name = "somename" ;
}
12.在当前作用域存储应用的外部变量
运行缓慢的代码：
function doSomething ( text ) {
var divs = document . getElementsByTagName ( 'div' ) ,
text = [ 'foo' , /* ... n ... */ , 'bar' ] ;
for ( var i = 0 , l = divs . length ; i < l ; i ++ ) {
divs [ i ] . innerHTML = text [ i ] ;
}
}
运行更快的代码：
function doSomethingFaster ( text ) {
var doc = document ,
divs = doc . getElementsByTagName ( 'div' ) ,
text = [ 'foo' , /* ... n ... */ , 'bar' ] ;
for ( var i = 0 , l = divs . length ; i < l ; i ++ ) {
divs [ i ] . innerHTML = text [ i ] ;
}
}
如果你需要访问一个元素（如 head）在一个大的循环中，使用一个本地的DOM访问(如例子中的get)会更快。
function doSomethingElseFaster ( ) {
var get = document . getElementsByTagName ;
for ( var i = 0 , i < 100000 ; i ++ ) {
get ( 'head' ) ;
}
}
13.使用变量缓存值
例子1.计算执行前在循环体内使用变量存储数学函数
var d = 35 ;
for ( var i = 0 ; i < 1000 ; i ++ ) {
y += Math . sin ( d ) * 10 ;
}
更好的处理：
var d = 55 ;
var math_sind = Math . sin ( d ) * 10 ;
for ( var i = 0 ; i < 1000 ; i ++ ) {
y += math_sind ;
}
例子2.保存数组的长度在循环中使用
for ( var i = 0 ; i < arr . length ; i ++ ) {
// do something
}
更好的改进：
for ( var i = 0 , len = arr . length ; i < len ; i ++ ) {
// do something
}
总的来说，如果已经做了一次，我们就不需要重复的做不必要的工作。例如，作用域或者函数中多次使用到计算的一个表达式的值，保存到变量可以使它多次被使用，否则我们会过头的声明一个变量并赋值然后只适用一次。所以请记住这些。
via JavaScript Performance Best Practices
