JavaScript 中的陷阱

全局变量

JavaScript 经过函数管理做用域。在函数内部声明的变量只在这个函数内部，函数外面不可用。另外一方面，全局变量就是在任何函数外面声明的或是未声明直接简单使用的。

“未声明直接简单使用”，指的是不用 var 关键字来声明变量。这个咱们已经很是清楚，避免形成隐式产生全局变量的方法就是声明变量尽可能用 var 关键字。

可你觉得用了 var 就 ok 了？来看看这个陷进：

1 2 3 4

function foo() {     var a = b = 0;     // body... }

也许你指望获得的是两个局部变量，但 b 倒是货真价实的全局变量。why? Because 赋值运算是自右往左的 ，因此这至关于：

1 2 3 4

function foo() {     var a = (b = 0);     // body... }

因此 b 是全局变量。

解决：变量声明，最好一个个来，别搞批发~_~;

变量声明

先来看陷阱：

1 2 3 4 5 6 7 8 9

myName = "global";   function foo() {     alert(myName);     var myName = "local";     alert(myName); }   foo();

乍看上去，咱们预计指望两次 alert 的结果分别为 “global” 与 “local”，但真实的结果是 “undefined” 与 “local”。why? Because 变量在同一做用域（同一函数）中，声明都是被提至做用域顶部先进行解析的。

因此以上代码片断的执行行为可能就像这样：

1 2 3 4 5 6

function foo() {     var myName;     alert(myName); // "undefined"     myName = "local";     alert(myName); // "local" }

用另外一个陷阱来测试下你是否真的理解了预解析：

1 2 3 4 5

if (!("a" in window)) {     var a = 1; }   alert(a);

a 变量的声明被提早到了代码顶端，此时还未赋值。接下来进入 if 语句，判断条件中 "a" in window 已成立（a 已被声明为全局变量），因此判断语句计算结果为 false，直接就跳出 if 语句了，因此 a 的值为 undefined。

1 2 3 4 5 6 7 8

var a; // "undefined" console.log("a" in window); // true   if (!("a" in window)) {     var a = 1; // 不执行 }   alert(a); // "undefined"

解决：变量声明，最好手动置于做用域顶部，对于没法当下赋值的变量，可采起先声明后赋值的手法。

函数声明

函数声明也是被提早至做用域顶部，先于任何表达式和语句被解析和求值的

1 2 3 4 5

alert(typeof foo); // "function"   function foo() {     // body... }

能够对比一下：

1 2 3 4 5

alert(typeof foo); // "undefined"   var foo = function () {     // body... };

明白了这个道理的你，是否还会掉入如下的陷阱呢？

1 2 3 4 5 6 7 8 9 10 11

function test() {     alert("1"); }   test();   function test() {     alert("2"); }   test();

运行以上代码片断，看到的两次弹窗显示的都是 “2”，为何不是分别为 “1” 和 “2” 呢？很简单，test 的声明先于 test() 被解析，因为后者覆盖前者，因此两次执行的结果都是 “2”。

解决：多数状况下，我用函数表达式来代替函数声明，特别是在一些语句块中。

函数表达式

先看命名函数表达式，理所固然，就是它得有名字，例如：

1 2 3

var bar = function foo() {     // body... };

要注意的是：函数名只对其函数内部可见。如如下陷阱：

1 2 3 4 5

var bar = function foo() {     foo(); // 正常运行 };   foo(); // 出错：ReferenceError

解决：尽可能少用命名函数表达式（除了一些递归以及 debug 的用途），切勿将函数名使用于外部。

函数的自执行

对于函数表达式，能够经过后面加上 () 自执行，并且可在括号中传递参数，而函数声明不能够。陷阱：

1 2 3 4 5

// (1) 这只是一个分组操做符，不是函数调用！ // 因此这里函数未被执行，依旧是个声明 function foo(x) {   alert(x); }(1);

如下代码片断分别执行都弹窗显示 “1”，由于在 (1) 以前，都为函数表达式，因此这里的 ()非分组操做符，而为运算符，表示调用执行。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

// 标准的匿名函数表达式 var bar = function foo(x) {   alert(x); }(1);   // 前面的 () 将 function 声明转化为了表达式 (function foo(x) {   alert(x); })(1);   // 整个 () 内为表达式 (function foo(x) {   alert(x); }(1));   // new 表达式 new function foo(x) {   alert(x); }(1);   // &&, ||, !, +, -, ~ 等操做符（还有逗号），在函数表达式和函数声明上消除歧义 // 因此一旦解析器知道其中一个已是表达式了，其它的也都默认为表达式了 true && function foo(x) {   alert(x); }(1);

解决：这个陷阱的关键在于，弄清楚形形色色函数表达式的实质。

循环中的闭包

如下演示的是一个常见的陷阱：

1 2 3 4 5 6 7 8

var links = document.getElementsByTagName("ul")[0].getElementsByTagName("a");   for (var i = 0, l = links.length; i < l; i++) {     links[i].onclick = function (e) {         e.preventDefault();         alert("You click link #" + i);     }         }

咱们预期当点击第 i 个连接时，获得此序列索引 i 的值，可实际不管点击哪一个连接，获得的都是 i 在循环后的最终结果：”5”。

解释一下缘由：当 alert 被调用时，for 循环内的匿名函数表达式，保持了对外部变量 i的引用（闭包），此时循环已结束，i 的值被修改成 “5”。

解决：为了获得想要的结果，须要在每次循环中建立变量 i 的拷贝。如下演示正确的作法：

1 2 3 4 5 6 7 8 9 10

var links = document.getElementsByTagName("ul")[0].getElementsByTagName("a");   for (var i = 0, l = links.length; i < l; i++) {     links[i].onclick = (function (index) {         return function (e) {             e.preventDefault();             alert("You click link #" + index);         }     })(i); }

能够看到，(function () { ... })() 的形式，就是上文提到的 函数的自执行 ，i 做为参数传给了 index，alert 再次执行时，它就拥有了对 index 的引用，此时这个值是不会被循环改变的。固然，明白了其原理后，你也能够这样写：

JavaScript

1 2 3 4 5 6 7 8

for (var i = 0, l = links.length; i < l; i++) {     (function (index) {         links[i].onclick = function (e) {             e.preventDefault();             alert("You click link #" + index);         }     })(i); }