JavaScript 從定義到執行,引擎在實作層做了不少初始化工作。要理解這套機制,得先認識幾個核心組件:執行環境堆疊、全域物件、執行環境、變數物件、活動物件、作用域與作用域鏈。本文不做逐一名詞解釋,而是用一個簡單範例,把引擎從定義到執行的每個環節串起來看。
var x = 1; // 全域變數 x
function A(y){
var x = 2; // 區域變數 x
function B(z){ // 內部函式 B
console.log(x + y + z);
}
return B; // 回傳 B 的引用
}
var C = A(1); // 執行 A,得到 B
C(1); // 執行 B,輸出 4這是一個典型的閉包,輸出為 4。以下分三個階段拆解。
引擎進入可執行程式碼時,會完成三件事。
第一,建立全域物件。它全域只有一份,屬性在任何地方都可存取,生命週期等同整個應用。Math、String、Date、document 等常用物件都掛在它上面。由於它無法用名稱直接存取,因此另外有一個 window 屬性指向自身:
var globalObject = {
Math: {}, String: {}, Date: {}, document: {},
// ...DOM 操作
window: this // 讓 window 指向自己
}第二,建立執行環境堆疊與全域執行環境。每個函式都有自己的執行環境,被呼叫時推入堆疊頂端取得執行權,執行完畢後移出,把執行權交還上一層。這保證了程式碼依正確順序執行:
var ECStack = []; // 執行環境堆疊
var EC = {}; // 執行環境(規範未定義具體資料結構,可理解為一塊記憶體空間)
ECStack.push(EC); // 進入函式,壓入執行環境
ECStack.pop(EC); // 函式返回後移出第三,建立與 EC 關聯的全域變數物件 VO。VO 指向全域物件,除了原有屬性,還包含全域宣告的變數 x 與函式 A。同時,定義函式 A 時會為它加上內部屬性 scope 並指向 VO。每個函式在定義時都會建立 scope,且總是指向定義時所在的環境——這句話是後面所有推論的基礎。此時堆疊結構如下:
ECStack = [
EC(G) = { // 全域執行環境
VO(G): { // 全域變數物件
// ...全域物件原有屬性
x = 1,
A = function(){...},
A[[scope]] = this // 指向 VO 本身
}
}
];進入 A(1) 時:
首先建立 A 的執行環境 EC 並推入堆疊頂端,此時堆疊有兩層,A 在上、全域在下。
接著建立 A 的作用域鏈。每個執行環境都有其作用域鏈,用於標識符解析,初始化為當前函式 scope 所包含的物件。
然後建立 A 的活動物件 AO。AO 扮演變數物件的角色(在函式中換了個名字),內容包含形參、arguments、this,以及區域變數與內部函式定義,並被推入作用域鏈頂端。此時定義 B,引擎同樣為 B 加上 scope 並指向「定義 B 時所在的環境」,也就是 A 的 AO;由於 AO 位於鏈表前端,而鏈表首尾相連,因此 B 的 scope 實際上指向 A 的整個作用域鏈。
ECStack = [
EC(A) = {
[scope]: VO(G),
AO(A) : {
y: 1,
x: 2,
B: function(){...},
B[[scope]] = this, // this 即 AO,AO 位於 scopeChain 頂端
arguments: [],
this: window // 函式中的 this 指向呼叫者
},
scopeChain: <AO(A), A[[scope]]> // 結果為 AO(A) -> VO(G)
},
EC(G) = { VO(G): { x = 1, A = function(){...}, A[[scope]] = VO(G) } }
];A 執行完後回傳 B 的引用並賦值給 C,因此 C(1) 等同 B(1)。流程與前面相同:建立 B 的 EC 並推入堆疊頂端(注意 A 的執行環境此時已被移出堆疊),建立 B 的作用域鏈並初始化為 B 的 scope(即包含 A 的作用域鏈),最後建立 B 的 AO,把形參 z、arguments 與 this 作為屬性。
ECStack = [
EC(B) = {
[scope]: AO(A), // 指向 A 的作用域鏈 AO(A) -> VO(G)
var AO(B) = { z: 1, arguments: [], this: window },
scopeChain: <AO(B), B[[scope]]> // AO(B) -> AO(A) -> VO(G)
},
EC(A), // A 的執行環境已從堆疊移出
EC(G) = { VO(G): { x = 1, A = function(){...} } }
];執行 x+y+z 時,引擎需逐一解析三個標識符,規則是:先查自己的 AO,命中則停止;否則沿作用域鏈由頂端往下找;整条鏈都找不到則回傳 undefined。B 的作用域鏈是:
AO(B) -> AO(A) -> VO(G)
所以 x 在 AO(A) 就被找到(值為 2,不會去查 VO(G) 的 x),y 也在 AO(A),z 則在自身的 AO(B)。最終 2 + 1 + 1 = 4。
理解這套機制不是為了背概念,而是為了拿它當工具改進程式碼。以標識符解析為例:作用域鏈越長,查找成本越高。經常被引用的全域物件(尤其 window、document 這種位於鏈表最底端的)若反覆查找,開銷並不便宜。常見的優化就是把常用全域引用在函式頂端存成區域變數,讓查找提前在 AO 階段命中。
同理,閉包之所以「記得住變數」,本質上是因為函式的 AO 仍被作用域鏈引用著,GC 因此不敢回收。把這層關係想通,很多看似神奇的行為都能自行推導。本文僅作拋磚引玉,歡迎留言交流。