ECMA-262-3 深入解析.第四章. 作用域链

说明：非常感谢justin对本文一些翻译不准确的地方提出的修改意见，对于那些修改的地方本人不作明确标注，justin也在翻译这篇文章，读者可以关注justin的blog了解最新动态。

  1. 导言
  2. 定义
  3. 函数生命周期
    1. 函数创建
    2. 函数激活
  4. 作用域特征
    1. 闭包
    2. 通过函数构造器创建的函数[[scope]]
    3. 二维作用域链查找
    4. 全局和eval上下文的作用域链
    5. 代码执行期间对作用域链的影响
  5. 结论
  6. 其他参考

导言

在第二章关于变量对象的描述中，我们已经知道一个执行上下文 的数据（变量、函数声明和函数的形参）作为属性存储在变量对象中。

同时我们也知道变量对象在每次进入上下文时创建，并填入初始值，值的更新出现在代码执行阶段。

这一章专门讨论与执行上下文直接相关的更多细节，这次我们将提及一个议题——作用域链。

定义

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

我们知道，ECMAScript 允许创建内部函数，我们甚至能从父函数中返回这些函数。

01.var x = 10;
02. 
03.function foo() {
04. 
05.var y = 20;
06. 
07.function bar() {
08.alert(x + y);
09.}
10. 
11.return bar;
12. 
13.}
14. 
15.foo()();// 30

这样，很明显每个上下文拥有自己的变量对象 ，对于全局上下文，它是全局对象自身，对于函数，它是激活对象。

作用域链完全是内部上下文所有变量对象（包括父变量对象）的列表。此链用来变量查询。即在上面的例子中，“bar”上下文的作用域链包括AO(bar)、AO(foo)和VO(global)。

但是，让我们仔细研究这个问题。

让我们从定义开始，并进深一步的讨论示例。

作用域链与一个执行上下文相关，变量对象的一条链在标识符解析中用于变量查找。

一个函数上下文的作用域链在函数调用时创建，包含激活对象和这个函数内部的[[scope]]属性。下面我们将更详细的讨论一个函数的[[scope]]属性。

在上下文中示意如下：

1.activeExecutionContext = {
2.VO: {...},// or AO
3.this: thisValue,
4.Scope: [// Scope chain
5.// list of all variable objects
6.// for identifiers lookup
7.]
8.};

其scope定义如下：

1.Scope = AO + [[Scope]]

这种联合和标识符解析过程，我们将在下面讨论，这与函数的生命周期相关。

函数的生命周期

函数的的生命周期分为创建和激活阶段（调用时），让我们详细研究它。

函数创建

众所周知，在进入上下文时函数声明放到变量/激活（VO/AO）对象中。让我们看看在全局上下文中的变量和函数声明（这里变量对象是全局对象自身，我们还记得，是吧？）

1.var x = 10;
2.function foo() {
3.var y = 20;
4.alert(x + y);
5.}
6.foo();// 30

在函数激活时，我们得到正确的（预期的）结果－－30。但是，有一个很重要的特点。

此前，我们仅仅谈到有关当前上下文的变量对象。这里，我们看到变量“y”在函数“foo”中定义（意味着它在foo上下文的AO中），但是变量“x”并未在“foo”上下文中定义，相应地，它也不会添加到“foo”的AO中。乍一看，变量“x”相对于函数“foo”并不存在生；但正如我们在下面看到的——也仅仅是“一瞥”，我们发现，“foo”上下文的激活对象中仅包含一个属性－－“y”。

1.fooContext.AO = {
2.y: undefined// undefined – on entering the context, 20 – at activation
3.};

函数“foo”如何访问到变量“x”？逻辑上假定函数应该访问一个更高一层上下文的变量对象。实际上它正是这样，这种机制是通过函数内部的[[scope]]属性来实现的。

[[scope]]是所有父变量对象的层级链，处于当前函数上下文之上，在函数创建时存于其中。

注意这重要的一点－－[[scope]]在函数创建时被存储－－静态（不变的），永远永远，直至函数销毁。即：函数永不调用，但[[scope]]属性已经写入，并存储在函数对象中。

另外一个需要考虑的是－－与作用域链对比，[[scope]]是函数的一个属性而不是上下文。考虑到上面的例子，函数“foo”的[[scope]]如下：

1.foo.[[Scope]] = [
2.globalContext.VO// === Global
3.];

举例来说，我们用通常的ECMAScript 数组展现作用域和[[scope]]。

继续，我们知道在函数调用时进入上下文，这里激活对象被创建，this和作用域（作用域链）被确定。让我们详细考虑这一时刻。

函数激活

正如在定义中谈到的那样，进入上下文创建AO/VO之后，上下文的Scope属性（变量查找的一个作用域链）作如下定义：

1.Scope = AO|VO + [[Scope]]

上面代码的意思是：激活对象是作用域数组的第一个对象，即添加到作用域的前端。

1.Scope = [AO].concat([[Scope]]);

这个特点对于标示符解析的处理来说很重要。

标示符解析是一个处理过程，用来确定一个变量（或函数声明）属于哪个变量对象。

这个算法的返回值中，我们总有一个引用类型，它的base元件是相应的变量对象（或若未找到则为null）,属性名元件是向上查找的标示符的名称。引用类型的详细信息在第三章.this中已讨论。

标识符解析过程包含与变量名对应属性的查找，即作用域中变量对象的连续查找，从最深的上下文开始，绕过作用域链直到最上层。

这样一来，在向上查找中，一个上下文中的局部变量较之于父作用域的变量拥有较高的优先级。万一两个变量有相同的名称但来自不同的作用域，那么第一个被发现的是在最深作用域中。

我们用一个有些复杂的例子描述上面讲到的这些。

01.var x = 10;
02.function foo() {
03.var y = 20;
04.function bar() {
05.var z = 30;
06.alert(x +  y + z);
07.}
08.bar();
09.}
10.foo();// 60

对此，我们有如下的变量/激活对象，函数的的[[scope]]属性以及上下文的作用域链：

全局上下文的变量对象是：

1.globalContext.VO === Global = {
2.x: 10
3.foo: <reference to function>
4.};

在“foo”创建时，“foo”的[[scope]]属性是：

1.foo.[[Scope]] = [
2.globalContext.VO
3.];

在“foo”激活时（进入上下文），“foo”上下文的激活对象是：

1.fooContext.AO = {
2.y: 20,
3.bar: <reference to function>
4.};

“foo”上下文的作用域链为：

1.fooContext.Scope = fooContext.AO + foo.[[Scope]]// i.e.:
2.fooContext.Scope = [
3.fooContext.AO,
4.globalContext.VO
5.];

内部函数“bar”创建时，其[[scope]]为：

1.bar.[[Scope]] = [
2.fooContext.AO,
3.globalContext.VO
4.];

在“bar”激活时，“bar”上下文的激活对象为：

1.barContext.AO = {
2.z: 30
3.};

“bar”上下文的作用域链为：

1.barContext.Scope = barContext.AO + bar.[[Scope]]// i.e.:
2.barContext.Scope = [
3.barContext.AO,
4.fooContext.AO,
5.globalContext.VO
6.];

对“x”、“y”、“z”的标识符解析如下：

01.- "x"
02.-- barContext.AO// not found
03.-- fooContext.AO// not found
04.-- globalContext.VO// found - 10
05. 
06.- "y"
07.-- barContext.AO// not found
08.-- fooContext.AO// found - 20
09. 
10.- "z"
11.-- barContext.AO// found - 30

作用域特征

让我们看看与作用域链和函数[[scope]]属性相关的一些重要特征。

闭包

在ECMAScript 中，闭包与函数的[[scope]]直接相关，正如我们提到的那样，[[scope]]在函数创建时被存储，与函数共存亡。实际上，闭包是函数代码和其[[scope]]的结合。因此，作为其对象之一，[[Scope]]包括在函数内创建的词法作用域（父变量对象）。当函数进一步激活时，在变量对象的这个词法链（静态的存储于创建时）中，来自较高作用域的变量将被搜寻。

例如：

1.var x = 10;
2.function foo() {
3.alert(x);
4.}
5.(function () {
6.var x = 20;
7.foo();// 10, but not 20
8.})();

我们看到，变量“x”在“foo”中被发现，即变量在函数创建时定义的词法（闭包）作用域查找，而不是在函数调用时的动态链（这样变量“x”将被解析为20）中查找。

闭包另一个经典的例子：

01.function foo() {
02.var x = 10;
03.var y = 20;
04.return function () {
05.alert([x, y]);
06.};
07.}
08.var x = 30;
09.var bar = foo();// anonymous function is returned
10.bar();// [10, 20]

我们再次看到，在标识符解析过程中，使用函数创建时定义的词法作用域－－变量解析为10，而不是30。此外，这个例子也清晰的表明，一个函数（这个例子中为从函数“foo”返回的匿名函数）的[[scope]]持续存在，即使是在函数创建的作用域已经完成之后。

关于ECMAScript 中闭包的理论和其执行机制的更多细节，阅读Chapter 6. Closures。

通过构造器创建的函数的[[scope]]

在上面的例子中，我们看到，在函数创建时获得函数的[[scope]]属性，通过该属性访问到所有父上下文的变量。但是，这个规则有一个重要的例外，它涉及到通过函数构造器创建的函数。

01.var x = 10;
02.function foo() {
03.var y = 20;
04.function barFD() {// FunctionDeclaration
05.alert(x);
06.alert(y);
07.}
08.var barFE = function () {// FunctionExpression
09.alert(x);
10.alert(y);
11.};
12.var barFn = Function('alert(x); alert(y);');
13.barFD();// 10, 20
14.barFE();// 10, 20
15.barFn();// 10, "y" is not defined
16.}
17.foo();

我们看到，通过函数构造器（Function constructor）创建的函数“bar”，变量“y”不能访问。但这并不意味着函数“barFn”没有[[scope]]属性（否则它不能访问到变量“x”）。问题在于通过函数构造器创建的函数的[[scope]]属性总是包含唯一的全局对象。考虑到这一点，如通过这种函数创建除全局之外的最上层的上下文闭包是不可能的（这句翻译的有些晦涩，参看原文：Consider it since, for example, to create closure of upper contexts, except global, via such function is not possible）。

二维作用域链查找

在作用域链中查找最重要的一点是变量对象的prototype（如果有的话）须考虑其中－－源于ECMAScript 的原型特性。如果一个属性在对象中没有直接找到，查询将在原型链中继续。即常说的二维链查找。（1）作用域链环节；（2）每个作用域链－－深入到原型链环节。如果在Object.prototype 中定义了属性，我们能看到这种效果。

1.function foo() {
2.alert(x);
3.}
4.Object.prototype.x = 10;
5.foo();// 10

激活对象没有原型，我们可以在下面的例子中看到：

01.function foo() {
02.var x = 20;
03.function bar() {
04.alert(x);
05.}
06.bar();
07.}
08.Object.prototype.x = 10;
09.foo();// 20

如果函数“bar”上下文的激活对象有一个原型，那么“x”将在Object.prototype 中被解析，因为它在AO中不被直接解析。但在上面的第一个例子中，在标识符解析中，我们到达全局对象（在一些执行中并不全是这样），它从Object.prototype继承而来，响应地，“x”解析为10。

同样的情况出现在一些版本的SpiderMokey 的命名函数表达式（缩写为NFE）中，在那里特定的对象存储从Object.prototype继承而来的函数表达式的可选名称，在Blackberry中的一些版本中，执行时激活对象从Object.prototype继承。但是，关于该特色的更多细节在Chapter 5. Functions.讨论。

全局和eval上下文中的作用域链

这里不一定很有趣，但必须要提示一下。全局上下文的作用域链仅包含全局对象。代码eval的上下文与当前的调用上下文（calling context）拥有同样的作用域链(这句翻译未按原文翻译，可参看execution context 来理解)。

1.globalContext.Scope = [
2.Global
3.];
4.evalContext.Scope === callingContext.Scope;

代码执行时对作用域链的影响

在ECMAScript 中，在代码执行阶段有两个声明能修改作用域链。这就是with声明和catch语句。它们添加到作用域链的最前端，对象须在这些声明中出现的标识符中查找。如果发生其中的一个，作用域链简要的作如下修改：

1.Scope = withObject|catchObject + AO|VO + [[Scope]]

在这个例子中添加对象，对象是它的参数（这样，没有前缀，这个对象的属性变得可以访问）。

1.var foo = {x: 10, y: 20};
2.with (foo) {
3.alert(x);// 10
4.alert(y);// 20
5.}

我们再次看到，通过with语句，对象中标识符的解析添加到作用域链的最前端：

1.var x = 10, y = 10;
2.with ({x: 20}) {
3.var x = 30, y = 30;
4.alert(x);// 30
5.alert(y);// 30
6.}
7.alert(x);// 10
8.alert(y);// 30

在进入上下文时发生了什么？标识符“x”和“y”已被添加到变量对象中。此外，在代码运行阶段作如下修改：

  • x = 10, y = 10;
  • 对象{x:20}添加到作用域的前端;
  • 在with内部，遇到了var声明，当然什么也没创建，因为在进入上下文时，所有变量已被解析添加;
  • 在第二步中，仅修改变量“x”，实际上对象中的“x”现在被解析，并添加到作用域链的最前端，“x”为20，变为30;
  • 同样也有变量对象“y”的修改，被解析后其值也相应的由10变为30;
  • 此外，在with声明完成后，它的特定对象从作用域链中移除（已改变的变量“x”－－30也从那个对象中移除），即作用域链的结构恢复到with得到加强以前的状态。
  • 在最后两个alert中，当前变量对象的“x”保持同一，“y”的值现在等于30，在with声明运行中已发生改变。

同样，catch语句的异常参数变得可以访问，它创建了只有一个属性的新对象－－异常参数名。图示看起来像这样：

1.try {
2....
3.} catch (ex) {
4.alert(ex);
5.}

作用域链修改：

1.var catchObject = {
2.ex: <exception object>
3.};
4.Scope = catchObject + AO|VO + [[Scope]]

在catch语句完成运行之后，作用域链恢复到以前的状态。

结论

在这个阶段，我们几乎考虑了与执行上下文相关的所有常用概念，以及与它们相关的细节。按照计划－－函数对象的详细分析：函数类型（FunctionDeclaration, FunctionExpression）和闭包。顺便说一下，在这篇文章中，闭包直接与[[scope]]属性相关，但是，关于它将在合适的篇章中讨论。我很乐意在评论中回答你的问题。

其它参考

原文地址：http://dmitrysoshnikov.com/ecmascript/chapter-4-scope-chain/

转载地址：http://www.denisdeng.com/?p=908
posted @ 2011-07-28 16:57  looping  阅读(238)  评论(0)  编辑  收藏  举报