DIV CSS 佈局教程網

深入理解 JavaScript(14):作用域鏈 Scope Chain
編輯:關於JavaScript     

前言

第 12 章談變數對象時我們提到,一個執行上下文的資料(變數、函式聲明與函式形參)以屬性形式存在變數對象中;變數對象在每次進入上下文時建立並填入初始值,值的更新則發生在程式碼執行階段。

本章要接著往下談一個與執行上下文直接相關的議題——作用域鏈。

英文原文:https://dmitrysoshnikov.com/ecmascript/chapter-4-scope-chain/

定義

作用域鏈大多與內部函式相關。ECMAScript 允許建立內部函式,甚至能從父函式中把它們回傳出去:

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

每個上下文都有自己的變數對象:全域上下文用的是全域物件本身,函式上下文用的是活動對象。而作用域鏈正是當前上下文中所有變數對象(包含父變數對象)組成的清單,用於變數查詢。上例中,bar 的作用域鏈包含 AO(bar)、AO(foo) 與 VO(global)。

形式化地說:作用域鏈與執行上下文相關,是變數對象的鏈,用於識別符解析中的變數查找。函式上下文的作用域鏈在函式呼叫時建立,包含活動對象與該函式的 [[scope]] 屬性。

activeExecutionContext = {
VO: {...},   // 或 AO
this: thisValue,
Scope: [     // 作用域鏈
// 所有變數對象的清單,用於識別符查詢
]
};
Scope = AO + [[Scope]]

函式的生命週期

函式的生命週期分為建立與激活(呼叫)兩個階段。

建立階段

進入上下文時,函式聲明會被放進變數/活動對象中。以全域上下文為例(此處變數對象就是全域物件本身):

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

呼叫時得到正確結果 30,但這裡有個重點:變數 y 在 foo 中定義(屬於 foo 的 AO),而 x 並未在 foo 中定義,因此也不會被加進 foo 的 AO。乍看之下 x 對 foo 而言並不存在——foo 的活動對象只有一個屬性 y:

fooContext.AO = {
y: undefined // 進入上下文時是 undefined,激活時變成 20
};

那 foo 如何存取到 x?答案是透過函式內部的 [[scope]] 屬性——它是所有父變數對象組成的層級鏈,位於當前函式上下文之上,在函式建立時就存在其中。

關鍵點:[[scope]] 在函式建立時即被保存,是靜態的、不變的,直到函式銷毀為止。也就是說,函式可以從來不被呼叫,但 [[scope]] 屬性已經寫好並存在函式物件裡。另外,[[scope]] 是函式的屬性,而不是上下文的屬性。上例中:

foo.[[Scope]] = [
globalContext.VO // === Global
];

激活階段

進入上下文、建立 AO/VO 之後,上下文的 Scope 屬性定義如下:

Scope = AO|VO + [[Scope]]

// 即
Scope = [AO].concat([[Scope]]);

也就是說,活動對象被放到作用域鏈的最前端。這個特性對識別符解析至關重要。

識別符解析是決定某個變數(或函式聲明)屬於哪個變數對象的過程。演算法的回傳值總是一個 Reference 型別:base 元件是對應的變數對象(找不到則為 null),property name 元件則是向上查找的識別符名稱。

解析過程就是從最深的上下文開始,沿著作用域鏈逐層向上查找同名屬性,直到最上層。因此區域變數的優先級高於父作用域的變數;若不同作用域中有同名變數,會先命中最深處的那一個。

一個較完整的例子

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

全域上下文的變數對象:

globalContext.VO === Global = {
x: 10,
foo: <reference to function>
};

foo 建立時:

foo.[[Scope]] = [
globalContext.VO
];

foo 激活時:

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

fooContext.Scope = fooContext.AO + foo.[[Scope]] // 即:
fooContext.Scope = [
fooContext.AO,
globalContext.VO
];

內部函式 bar 建立時:

bar.[[Scope]] = [
fooContext.AO,
globalContext.VO
];

bar 激活時:

barContext.AO = {
z: 30
};

barContext.Scope = barContext.AO + bar.[[Scope]] // 即:
barContext.Scope = [
barContext.AO,
fooContext.AO,
globalContext.VO
];

於是 x、y、z 的解析過程為:

- "x"
-- barContext.AO  // 找不到
-- fooContext.AO  // 找不到
-- globalContext.VO // 找到 —— 10
- "y"
-- barContext.AO  // 找不到
-- fooContext.AO  // 找到 —— 20
- "z"
-- barContext.AO  // 找到 —— 30

作用域的重要特徵

閉包

在 ECMAScript 中,閉包與函式的 [[scope]] 直接相關:[[scope]] 在函式建立時保存、與函式共存亡。閉包就是函式程式碼與其 [[scope]] 的結合,其中包含了函式建立時的詞彙作用域(父變數對象)。函式激活時,會在這條靜態保存的詞彙鏈中搜尋來自高階作用域的變數。

var x = 10;
function foo() {
alert(x);
}
(function () {
var x = 20;
foo(); // 10,而不是 20
})();

解析過程使用的是函式建立時定義的詞彙作用域,所以結果是 10。這也說明:即使建立函式的作用域已經執行完畢,函式的 [[scope]] 依然存在。更多細節請看第 16 章。

透過建構子建立的函式

這個規則有一個重要例外:用 Function 建構子建立的函式。

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();

barFn 取不到 y,但並非它沒有 [[scope]](否則連 x 也取不到),而是它的 [[scope]] 永遠只有全域物件。因此用這種方式無法建立「除全域之外」的最上層閉包。

二維作用域鏈查找

作用域鏈查找有個容易被忽略的細節:變數對象的屬性查找會考慮原型特性。若屬性未在物件上直接找到,查詢會沿原型鏈繼續——這就是所謂的二維鏈查找:(1)作用域鏈環節;(2)每個作用域鏈再深入原型鏈環節。

function foo() {
alert(x);
}
Object.prototype.x = 10;
foo(); // 10

但活動對象沒有原型:

function foo() {
var x = 20;
function bar() {
alert(x);
}
bar();
}
Object.prototype.x = 10;
foo(); // 20

若 bar 的活動對象有原型,x 就會在 Object.prototype 中被解析;但在上例中它先在 foo 的 AO 命中。同樣的情況出現在某些 SpiderMonkey 版本的 NFE 中(特殊物件從 Object.prototype 繼承可選名稱),以及 Blackberry 某些版本(活動物件從 Object.prototype 繼承)。更多細節見第 15 章。

全域與 eval 上下文

全域上下文的作用域鏈只包含全域物件;eval 程式碼的上下文與呼叫它的上下文共用同一條作用域鏈。

globalContext.Scope = [
Global
];

evalContext.Scope === callingContext.Scope;

執行階段對作用域鏈的影響

ECMAScript 中有兩個語句能在執行階段修改作用域鏈:with 與 catch。它們會把一個物件加到作用域鏈最前端,於是在這些語句中出現的識別符會先在該物件上查找:

Scope = withObject|catchObject + AO|VO + [[Scope]]
var foo = {x: 10, y: 20};
with (foo) {
alert(x); // 10
alert(y); // 20
}

// 作用域鏈變成
Scope = foo + AO|VO + [[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

逐步來看:

  • 進入上下文時,識別符 x 與 y 已被加入變數對象,此時 x = 10、y = 10。
  • 物件 {x: 20} 被加到作用域鏈最前端。
  • with 內部遇到 var 宣告,但因為進入上下文時變數都已被解析建立,這裡什麼也不會發生。
  • 指派 x = 30 時,解析到作用域鏈最前端的物件屬性 x,於是它從 20 變成 30。
  • y = 30 在該物件上找不到,於是解析到變數對象的 y,從 10 變成 30。
  • with 結束後,特殊物件連同被改掉的 x(30)一起從作用域鏈移除,鏈結構恢復原狀。

所以最後兩個 alert 中,區域變數 x 仍是 10,而 y 已變成 30。

catch 同理:異常參數會被包進一個只有單一屬性的新物件並放到鏈的最前端。

try {
...
} catch (ex) {
alert(ex);
}
var catchObject = {
ex: <exception object>
};

Scope = catchObject + AO|VO + [[Scope]]

catch 執行完畢後,作用域鏈恢復原狀。

結論

至此,與執行上下文相關的常用概念大致都齊了。接下來會繼續談函式物件:函式類型(FD、FE)與閉包。本章中閉包直接對應 [[scope]] 屬性,完整的討論留待後續篇章。

其他參考:ECMA-262-3 的 8.6.2([[Scope]])與 10.1.4(Scope Chain and Identifier Resolution)。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved