posts - 8,comments - 6,trackbacks - 0

闭包真的是一个谈烂掉的内容。说到闭包,自然就涉及到执行环境、变量对象以及作用域链。汤姆大叔翻译的《深入理解JavaScript系列》很好,帮我解决了一直以来似懂非懂的很多问题,包括闭包。下面就给自己总结一下。包括参考大叔的译文以及《JavaScript高级程序设计(第3版)》,一些例子引用自它们。

附上大叔的链接:《深入理解JavaScript系列》

一、执行环境(或“执行上下文”,意义一样)

首先说下ECMAScript可执行代码的类型包括:全局代码、函数代码、eval()代码。

每当执行流转到可执行代码时,即会进入一个执行环境。活动的执行环境构成一个栈:栈的底部始终是全局环境,顶部是当前活动的执行环境。

❶全局执行环境是最外围的一个执行环境。在浏览器中,全局环境就是window对象,因此所有全局变量和函数都是作为window对象的属性和方法创建的。

❷每个函数都有自己的执行环境。当执行流进入一个函数时,函数的环境被推入栈中。而在函数执行之后,栈将其环境弹出,把控制权返回给之前的执行环境。某个执行环境中的代码执行完后,该环境销毁,保存在其中的所有变量和函数定义也随之销毁。而全局执行环境直到应用程序退出才会被销毁。

❸eval的执行环境与调用环境的执行环境相同。

二、变量对象

我们知道变量和执行环境有着密切的关系:

var a = 10; // 全局上下文中的变量
 
(function () {
  var b = 20; // function上下文中的局部变量
})();
 
alert(a); // 10
alert(b); // 全局变量 "b" 没有声明

而且我们也知道在JS里没有块级作用域这一说法,ES规范指出独立作用域只能通过函数(function)代码类型的执行环境创建。也就是说,像for循环并不能创建一个局部环境:

for (var k in {a: 1, b: 2}) {
  alert(k);
}
 
alert(k); // 尽管循环已经结束但变量k依然在当前作用域

既然变量与执行环境相关,那变量自己应该知道它的数据存放在哪里,并知道如何访问。这就引出了“变量对象”这个概念。

每个执行环境都有一个与之关联的变量对象,这个对象存储着在环境中定义的以下内容:

1. 函数的形参
2. var声明的变量
3. 函数声明(不包括函数表达式)

举例来说,用一个普通对象来表示变量对象,它是执行环境的一个属性:

执行环境 = {
   变量对象:{
       //环境中的数据
    }
};        

例如:

var a = 10;

function test(x) {
  var b = 20;
};

test(30);

对应的变量对象为:

// 全局执行环境的变量对象
全局环境的变量对象= {
  a: 10,
  test: 指向test()函数
};
 
// test函数执行环境的变量对象
test函数环境的变量对象 = {
  x: 30,
  b: 20
};

 那么,不同执行环境中的变量对象的初始化是怎样的呢?下面详细看一下:

❶全局环境中的变量对象

先看下全局对象的明确定义:

全局对象 是在进入任何执行环境之前就已经创建了的对象。
这个对象只存在一份,它的属性在程序中的任何地方都可以访问,全局对象的生命周期终止于程序退出那一刻。

全局对象初始创建阶段,将Math、String等作为自身属性,初始化如下:

globla = {
   Math:
   String:
   ...
   ...
   window:globla   //引用自身
};

在这里,变量对象就是全局对象自己。

❷函数环境中的变量对象

在函数执行环境中,“活动对象” 扮演着变量对象这个角色。活动对象是在进入函数执行环境时创建的,它通过函数的arguments属性初始化:

活动对象 = {
   arguments:  //是个对象,包括callee、length等属性 
}; 

理解了变量对象的初始化之后,下面就是关于变量对象的核心了。

环境中的代码,被分为两个阶段来处理:进入执行环境 、执行代码。变量对象的修改变化与这两个阶段紧密相关。

这2个阶段的处理是一般行为,和环境的类型无关(即,在全局环境和函数环境中的表现是一样的)。

①进入环境

当进入执行环境时(代码执行之前),变量对象已包含下列属性(上面有提到):

①函数的所有形参(如果是在函数执行环境中。因为全局环境没有形参。)
————由 形参名称 和 对应值 组成,作为变量对象的属性。如果没有传递对应的参数,将undefined作为对应值。

②所有函数声明(注意是声明,函数表达式不算。)
————由 函数名 和 对应值(函数对象)组成,作为变量对象的属性。如果变量对象已经存在同名的属性,则覆盖这个属性。

③所有变量声明(由var声明的变量)
————由 变量名 和 对应值(undefined) 组成,作为变量对象的属性。如果变量名与已经声明的形参或函数相同,则变量声明不会干扰已经存在的这类属性。
————注意:此时的对应值是undefined。

让我们来看一个例子:

function test(a, b) {
  alert(c);    //undefined
  alert(d);   //function d() {}
  alert(e);   //undefined
  alert(x);   //出错
  var c = 10;
  function d() {}
  var e = function _e() {};
  (function x() {});
}
 
test(10); //

 我们考虑当进入带有参数10的test函数环境时(代码执行之前),活动对象表现如下:

活动对象(test) = {
  a: 10,
  b: undefined,  
  c: undefined,
  d:指向函数d,
  e: undefined
};

注意,活动对象里不包含函数x。这是因为x是一个函数表达式而不是函数声明,函数表达式不会影响变量对象(在这里是活动对象)。函数_e同样是函数表达式,但是我们注意到它分配给了变量e,所以可以通过名称e来访问。

在这之后,将进入处理代码的第二个阶段:执行代码。

②执行代码

这个阶段内,变量/活动对象已经拥有了属性(不过,并不是所有属性都有值,就像上面那个例子,大部分属性的值还是系统默认的undefined)。

继续上面那个例子,活动对象在“执行代码”这个阶段被修改如下():

AO(test) = {
  a: 10,
  b: undefined,  //没有相应该参数传入,undefined
  c: 10,    //之前是undefined
  d: 指向函数d,
  e: 指向函数表达式_e   //之前是undefined
};

注意此时,函数表达式_e保存到了已声明的变量e上,但函数表达式"x"本身不存在于活动对象中,也就是说,如果尝试调用函数"x",无论在函数定义之前或之后,都会出现        “x is not defined”的错误。

理解了以上内容之后,再来看一个例子:

alert(x); // function
 
var x = 10;
alert(x); // 10
 
x = 20;
 
function x() {};

alert(x); // 20

为什么第一个alert(x)的值是function,而且它还是在x声明之前访问的x?为什么不是10或20呢?

现在我们知道,函数声明是在进入环境时填入活动对象的,同一时间,还有一个变量声明'x',但是正如前面所说,变量声明在顺序上跟在函数声明和形参声明之后。即,在进入环境阶段,变量声明不会干扰变量对象中已经存在的同名函数或形参声明。所以,就这个例子来说,在进入环境时,变量对象的结构如下:

变量对象 = {
    x:指向函数x
    //如果function x没有已经声明的话,这时的x应该是undefined
};

紧接着,在代码执行阶段,变量对象作如下修改:

变量对象['x'] = 10;
变量对象['x'] = 20;
//可以在第二、三个alert看到这个结果

再看一个例子:

if (true) {
   var a = 1;   
} else {
   var b = 2;
}
//变量是在进入环境阶段放入变量对象的,虽然else部分永远不会执行,
//但是不管怎样,变量b仍然存在于变量对象中。
alert(a); //1
alert(b); //undefined,不是b未声明,而是b的值是undefined

另外,关于var声明变量和不用var声明:

大叔的译文中指出:任何时候,变量只能通过var关键字才能声明。

像a = 10;这仅仅是给全局对象创建了一个新属性(但它不是变量)。它之所以能成为全局对象的属性,完全是因为全局对象===全局变量对象。看例子:

alert(a); // undefined
alert(b); // "b" 没有声明,出错
 
b = 10;
var a = 20;

进入环境阶段:

变量对象 = {
  a: undefined
};

可以看到,因为b不是一个变量,所以在这个阶段根本就没有b,b将只在代码执行阶段才会出现,但在这里,还未执行到那就出错了。

还有一个要注意的:var声明的变量,相对于属性(如a = 10;或window.a = 10;),变量的[[Configurable]]特性值为false,即不能通过delete删除,而属性则可以。

三、作用域链

现在我们已经知道,一个执行环境的数据(变量、函数声明和函数形参)作为属性存储在变量对象中。

同时也知道,变量对象在每次进入环境时创建,并填入初始值,值的更新出现在代码执行阶段。

下面的内容讨论作用域链。

如果要简要地描述并展示其重点,那么作用域链大多数与内部函数相关。

我们可以创建内部函数,甚至能从父函数中返回这些函数。

var x = 10;
 
function foo() { 
  var y = 20; 
  function bar() {
    alert(x + y);
  } 
  return bar; 
}
 
foo()(); // 30

很明显每个环境拥有自己的变量对象:对于全局环境,它是全局对象自身;对于函数,它是活动对象。

作用域链正是内部环境所有变量对象(包括父变量对象)的列表。此链用来在标识符解析中变量查找。

作用域链本质上,是一个指向变量对象的指针列表,它只引用但不实际包含变量对象。

对于上面这个例子,bar执行环境中的作用域链包括:bar变量对象、foo变量对象、全局变量对象。

函数执行环境中的作用域链在函数调用时创建,包含这个函数的活动对象和函数的[[scope]]属性。示例如下:

活动的执行环境 = {
    变量对象: {...}, // or 活动对象
    this: thisValue,
    Scope: [ // 作用域链
      // 它是所有变量对象的列表。
    ]
};

其中的Scope定义为:Scope = 被调用函数的活动对象 + [[scope]]。

这种标识符的解析过程,与函数的生命周期相关,下面详细讨论。

(1)函数的生命周期

函数的生命周期分为创建和激活(调用时)两个阶段。

❶函数创建

让我们先看看在全局环境中的变量和函数声明(这里的变量对象就是全局对象自身,我们懂的。)

var x = 10;
 
function foo() {
  var y = 20;
  alert(x + y);
}
 
foo(); // 30

函数激活时,得到了正确的也是预期中的结果。但我们注意到,变量y在函数foo中定义(意味着它在foo的活动对象中),但是x并未在foo环境中定义,相应地,它不会添加到foo的活动对象中。那么,foo是如何访问到变量x的?其实我们大都知道函数能访问更高一层的环境中的变量对象,事实也是如此,而这种机制正是通过函数内部的[[scope]]属性实现的。

[[scope]]是所有父变量对象的层级链,处于当前函数环境,在函数创建时存在于其中。

注意重要的一点:[[scope]]属性在函数创建时被存储,永远不变,直到函数销毁。函数可以不被调用,但这个属性一直存在。
且,与作用域链相比,作用域链是执行环境的一个属性,而[[scope]]是函数的属性。

上面的例子,函数foo的[[scope]]如下:

foo.[[Scope]] = [
  全局执行环境.变量对象 // === Global
];

继续,我们知道在函数调用时进入执行环境,这时活动对象被创建,this、作用域链被确定。下面详细考虑这个时刻。

❷函数激活

正如上面提到的,进入环境创建变量/活动对象之后,环境的Scope属性(即作用域链)定义为:Scope = 变量/活动对象 + [[scope]]。

这个定义意思是:活动对象是被添加到[[scope]]前端,在作用域链中处理第一位。这很重要,对于标识符的查找,是从自身变量对象开始的,逐渐往父变量对象查找。

(2)通过构造函数创建的函数的[[scope]]

在上面的例子中,我们看到,在函数创建时,函数获得[[scope]]属性,该属性存储着所有父环境的变量/活动对象。但有一个例外,那就是通过构造函数创建的函数。

var x = 10;
 
function foo() {
 
  var y = 20;
 
  function barFD() { // 函数声明
    alert(x);
    alert(y);
  }
 
  var barFE = function () { // 函数表达式
    alert(x);
    alert(y);
  };
 
  var barFn = Function('alert(x); alert(y);');
 
  barFD(); // 10, 20
  barFE(); // 10, 20
  barFn(); // 10, "y" is not defined
 
}
 
foo();

从以上例子中,我们看出问题所在:通过构造函数创建的函数,它的[[scope]]仅包含全局对象。

另外关于eval,实践中很少用到eval,但有一点提示,eval代码的环境与当前的调用环境拥有相同的作用域链。

(3)延长作用域链

有两个能延长作用域链的方法:with声明和catch语句。它们添加到作用域链的最前端(比被调用函数的活动对象还要靠前)。

如果发生其中一个,作用域链作如下修改:

Scope = withObject|catchObject +活动/变量对象 + [[Scope]]

看个例子:

var x = 10, y = 10;
 
with ({x: 20}) {
 
  var x = 30, y = 30;
 
  alert(x); // 30
  alert(y); // 30
}
 
alert(x); // 10
alert(y); // 30
//1. x = 10,y = 10;
//2. 进入环境,对象{x:20}添加到作用域链的前端。
//3. 执行代码,x为20,变为30,y为10,变为30。
//4.with声明完成后,对象被移除,那个因with对象而改变的x=30也被移除。
//最后两个alert,x保持最初不变,y在with里已发生改变。

四、闭包

到了这里,其实如果对前面的[[scope]]和作用域链完全理解的话,闭包也就懂了。

大叔的译文对闭包给出的2个定义是:

❶从理论角度:所有函数都是闭包。因为它们在创建的时候就将所有父环境的数据保存起来了。哪怕是简单的全局变量也是如此,因为在函数中访问全局变量就相当于在访问自由变量(指不在参数声明,也不在局部声明的变量),这个时候使用最外层的作用域。

❷从实践角度:以下函数才算是闭包:

   ①即使创建它的环境销毁,它仍然存在(比如,内部函数从父函数返回);②在代码中引用了自由变量。

闭包的性能问题总被提及,现在我们知道原因了:创建闭包的父环境即使被销毁了,但闭包仍然引用着父环境的变量对象,也就是说需要继续维护着这个变量对象的内存。

下面我们再来具体看一下。

var x = 10;

function foo() {
  alert(x);
}

(function (funArg) {

  var x = 20;

  // 变量"x"在foo中静态保存的,在该函数创建的时候就保存了
  funArg(); // 10, 而不是20

})(foo);

我们已经知道,创建foo函数的父级环境(在这里是全局环境)的数据是保存在foo函数的内部属性[[scope]]中的。

这里还要注意的是:同一个父环境创建的闭包是共用一个[[scope]]属性的。也就是说,某个闭包对其中[[scope]]的变量的修改会影响到其他闭包对其变量的读取。

var firstClosure;
var secondClosure;

function foo() {

  var x = 1;

  firstClosure = function () { return ++x; };
  secondClosure = function () { return --x; };

  x = 2; // 影响"x", 在2个闭包公有的[[Scope]]中

  alert(firstClosure()); // 3, 通过第一个闭包的[[Scope]]
}

foo();

alert(firstClosure()); // 4
alert(secondClosure()); // 3

关于这个问题,大叔的译文和《JS高级》里都有一个例子:

var data = [];

for (var k = 0; k < 3; k++) {
  data[k] = function () {
    alert(k);
  };
}

data[0](); // 3, 而不是0
data[1](); // 3, 而不是1
data[2](); // 3, 而不是2

这就是闭包共用一个[[scope]]的问题。可以按下面的方法解决:

var data = [];

for (var k = 0; k < 3; k++) {
  data[k] = (function _helper(x) {
    return function () {
      alert(x);
    };
  })(k); // 传入"k"值
}

// 现在结果是正确的了
data[0](); // 0
data[1](); // 1
data[2](); // 2

在上例中,每次_helper都会创建一个新的变量对象,其中含有参数x,其值就是传递进来的k值。此时,返回的函数的[[scope]]如下:

data[0].[[Scope]] === [
  ... // 其它变量对象
  父级环境中的活动对象: {data: [...], k: 3},
  _helper环境中的活动对象: {x: 0}
];

data[1].[[Scope]] === [
  ... // 其它变量对象
  父级环境中的活动对象: {data: [...], k: 3},
  _helper环境中的活动对象: {x: 1}
];

data[2].[[Scope]] === [
  ... // 其它变量对象
  父级环境中的活动对象: {data: [...], k: 3},
  _helper环境中的活动对象: {x: 2}
];

要注意的是,如果在返回的函数中,要获取k值,那么该值还会是3。

五、小结

总结得好长啊好长。因为我觉得一口气将这几个点连在一起梳理一下比较好。

嗯,就这样吧。

posted on 2013-01-31 23:15 no_particular 阅读(...) 评论(...) 编辑 收藏