注：原文出自《JavaScript 中的一些坑（一）》http://roshanca.com/traps-in-javascript-part-I/ ，方便以后查找，所以就收藏了。
---------------------------------------------------------------------------------------------------------------------------------------------------------
由于 JavaScript “弱语言”的性质，使得其在使用过程中异常的宽松灵活，但也极为容易“掉进陷阱”。这些陷阱往往隐藏的很深，所以要多加小心。
全局变量
JavaScript 通过函数管理作用域。在函数内部声明的变量只在这个函数内部，函数外面不可用。（局部变量）
另一方面，全局变量就是在任何函数外面声明的或是未声明直接简单使用的。
“未声明直接简单使用”，指的是不用 var 关键字来声明变量。这个我们已经非常清楚，避免造成隐式产生全局变量的方法就是声明变量尽量用 var 关键字。
可你以为用了 var 就 ok 了？来看看这个陷进：
1 function foo() { 2 var a = b = 0; 3 // body... 4 }
也许你期望得到的是两个局部变量，但 b 却是货真价实的全局变量。why? Because 赋值运算是自右往左的 ，所以这相当于：
1 function foo() { 2 var a = (b = 0); 3 // body... 4 }
所以 b 是全局变量。
解决：变量声明，最好一个个来，别搞批发~_~;
变量声明
先来看陷阱：
1 myName = "global"; 2 3 function foo() { 4 alert(myName); 5 var myName = "local"; 6 alert(myName); 7 } 8 9 foo();
乍看上去，我们预计期望两次 alert 的结果分别为 “global” 与 “local”，但真实的结果是 “undefined” 与 “local”。
why? Because 变量在同一作用域（同一函数）中，声明都是被提至作用域顶部先进行解析的。
所以以上代码片段的执行行为可能就像这样：
1 function foo() { 2 var myName; 3 alert(myName); // "undefined" 4 myName = "local"; 5 alert(myName); // "local" 6 }
用另一个陷阱来测试下你是否真的理解了预解析：
1 if (!("a" in window)) { //'b' in window==>true 2 var a = 1; 3 } 4 5 alert(a);
a 变量的声明被提前到了代码顶端，此时还未赋值。接下来进入 if 语句，判断条件中 "a" in window 已成立（a 已被声明为全局变量），所以判断语句计算结果为 false，直接就跳出 if 语句了，所以 a 的值为 undefined。
1 var a; // "undefined" 2 console.log("a" in window); // true 3 4 if (!("a" in window)) { 5 var a = 1; // 不执行 6 } 7 8 alert(a); // "undefined"
解决：变量声明，最好手动置于作用域顶部，对于无法当下赋值的变量，可采取先声明后赋值的手法。
函数声明
函数声明也是被提前至作用域顶部，先于任何表达式和语句被解析和求值的
1 alert(typeof foo); // "function" 2 3 function foo() { 4 // body... 5 }
可以对比一下：
1 alert(typeof foo); // "undefined" 2 3 var foo = function () { 4 // body... 5 };
明白了这个道理的你，是否还会掉入以下的陷阱呢？
1 function test() { 2 alert("1"); 3 } 4 5 test(); 6 7 function test() { 8 alert("2"); 9 } 10 11 test();
运行以上代码片段，看到的两次弹窗显示的都是 “2”，为什么不是分别为 “1” 和 “2” 呢？很简单，test 的声明先于 test() 被解析，由于后者覆盖前者，所以两次执行的结果都是 “2”。
解决：多数情况下，我用函数表达式来代替函数声明，特别是在一些语句块中。
函数表达式
先看命名函数表达式，理所当然，就是它得有名字，例如：
1 var bar = function foo() { 2 // body... 3 };
要注意的是：函数名只对其函数内部可见。如以下陷阱：
1 var bar = function foo() { 2 foo(); // 正常运行 3 }; 4 5 foo(); // 出错：ReferenceError
解决：尽量少用命名函数表达式（除了一些递归以及 debug 的用途），切勿将函数名使用于外部。
函数的自执行
对于函数表达式，可以通过后面加上 () 自执行，而且可在括号中传递参数，而函数声明不可以。陷阱：
1 // (1) 这只是一个分组操作符，不是函数调用！ 2 // 所以这里函数未被执行，依旧是个声明 3 function foo(x) { 4 alert(x); 5 }(1);
以下代码片段分别执行都弹窗显示 “1”，因为在 (1) 之前，都为函数表达式，所以这里的 ()非分组操作符，而为运算符，表示调用执行。
1 // 标准的匿名函数表达式 2 var bar = function foo(x) { 3 alert(x); 4 }(1); 5 6 // 前面的 () 将 function 声明转化为了表达式 7 (function foo(x) { 8 alert(x); 9 })(1); 10 11 // 整个 () 内为表达式 12 (function foo(x) { 13 alert(x); 14 }(1)); 15 16 // new 表达式 17 new function foo(x) { 18 alert(x); 19 }(1); 20 21 // &&, ||, !, +, -, ~ 等操作符（还有逗号），在函数表达式和函数声明上消除歧义 22 // 所以一旦解析器知道其中一个已经是表达式了，其它的也都默认为表达式了 23 true && function foo(x) { 24 alert(x); 25 }(1);
解决：这个陷阱的关键在于，弄清楚形形色色函数表达式的实质。
循环中的闭包
以下演示的是一个常见的陷阱：
<!doctype html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Document</title>
</head>
<body>
<h3>when clicking links below, show the number of its sequence</h3>
<ul>
<li><a href="#">link #0</a></li>
<li><a href="#">link #1</a></li>
<li><a href="#">link #2</a></li>
<li><a href="#">link #3</a></li>
<li><a href="#">link #4</a></li>
</ul>
</body>
</html>
1 var links = document.getElementsByTagName("ul")[0].getElementsByTagName("a"); 2 3 for (var i = 0, l = links.length; i < l; i++) { 4 links[i].onclick = function (e) { 5 e.preventDefault(); 6 alert("You click link #" + i); 7 } 8 }
我们预期当点击第 i 个链接时，得到此序列索引 i 的值，可实际无论点击哪个链接，得到的都是 i 在循环后的最终结果：”5”。
解释一下原因：当 alert 被调用时，for 循环内的匿名函数表达式，保持了对外部变量 i的引用（闭包），此时循环已结束，i 的值被修改为 “5”。
解决：为了得到想要的结果，需要在每次循环中创建变量 i 的拷贝。以下演示正确的做法：
1 <!doctype html> 2 <html lang="en"> 3 <head> 4 <meta charset="UTF-8"> 5 <title>Document</title> 6 </head> 7 <body> 8 <h3>when clicking links below, show the number of its sequence</h3> 9 <ul> 10 <li><a href="#">link #0</a></li> 11 <li><a href="#">link #1</a></li> 12 <li><a href="#">link #2</a></li> 13 <li><a href="#">link #3</a></li> 14 <li><a href="#">link #4</a></li> 15 </ul> 16 </body> 17 </html>
1 var links = document.getElementsByTagName("ul")[0].getElementsByTagName("a"); 2 3 for (var i = 0, l = links.length; i < l; i++) { 4 links[i].onclick = (function (index) { 5 return function (e) { 6 e.preventDefault(); 7 alert("You click link #" + index); 8 } 9 })(i); 10 }
可以看到，(function () { ... })() 的形式，就是上文提到的 函数的自执行 ，i 作为参数传给了 index，alert 再次执行时，它就拥有了对 index 的引用，此时这个值是不会被循环改变的。当然，明白了其原理后，你也可以这样写：
1 for (var i = 0, l = links.length; i < l; i++) { 2 (function (index) { 3 links[i].onclick = function (e) { 4 e.preventDefault(); 5 alert("You click link #" + index); 6 } 7 })(i); 8 }