DIV CSS 佈局教程網

JavaScript 閉包入門:定義、作用域鏈與經典陷阱
編輯:關於JavaScript     

閉包大概是 JavaScript 裡最常被提起、也最常被誤解的概念。它並不神秘,只是牽涉到作用域鏈與垃圾回收的運作細節。本文從最簡單的例子出發,逐步拆解閉包的成因、代價與常見陷阱。

一、閉包是什麼

閉包是指有權存取另一個函式作用域中變數的函式。 最常見的建立方式,是在一個函式內部定義另一個函式,並把內層函式回傳出去。

function a() {
    var i = 0;
    function b() {
        alert(++i);
    }
    return b;
}
var c = a();
c();

這段程式有兩個關鍵特徵:函式 b 定義在 a 的內部,且 a 回傳了 b。執行 var c = a() 之後,c 實際上指向 b;再執行 c() 便會彈出 i 的值(第一次為 1)。

為什麼這叫閉包?因為 a 外部的變數 c 持有了 a 內部函式 b 的引用。當函式內部的函式被外部引用時,閉包就形成了。

二、閉包解決了什麼問題

最直白的說法是:閉包讓 JavaScript 的垃圾回收機制不敢回收外層函式佔用的資源,因為內層函式的執行還依賴外層的變數。

因此在上例中,a 執行完並回傳之後,i 依然存活在記憶體裡,每次呼叫 c() 都會讓 i 自增並印出新值。

反過來想:如果 a 回傳的不是函式 b,那 b 就只被 a 引用,a 也只被 b 引用,兩者互相引用卻不與外界連結,就會一起被回收。

三、作用域鏈:閉包的內部機制

要真正理解閉包,需要四個概念:執行環境(execution context)、活動物件(call object)、作用域(scope)與作用域鏈(scope chain)。以函式 a 從定義到執行的過程為例:

  1. 定義階段:解譯器把 a 的作用域鏈設定為「定義 a 時所在的環境」。若 a 是全域函式,作用域鏈裡就只有 window。
  2. 進入執行環境:呼叫 a 時,a 進入對應的執行環境。
  3. 建立 scope 屬性:執行環境會為 a 加上一個 scope 屬性,其值就是第 1 步的作用域鏈。
  4. 建立活動物件:執行環境建立一個活動物件,它擁有屬性、沒有原型,且無法用程式碼直接存取。建立後會被放到 a 的作用域鏈最頂端。此時 a 的作用域鏈含兩個物件:a 的活動物件與 window。
  5. 挂上 arguments:在活動物件上加入 arguments 屬性,保存呼叫時傳入的參數。
  6. 加入形參與內層函式:把 a 的形參與內部函式 b 的引用都掛到活動物件上。這一步完成了 b 的定義,因此 b 的作用域鏈被設為「b 被定義時的環境」,也就是 a 的作用域。

到這裡,a 把 b 的引用交給外部的 c;而 b 的作用域鏈裡含有對 a 活動物件的引用,所以 b 能讀到 a 中定義的所有變數。b 被 c 引用、b 又依賴 a,於是 a 不會被回收。

當 b 執行時也會經歷同樣流程,此時 b 的作用域鏈含三個物件:b 的活動物件、a 的活動物件、window。讀取變數時的搜尋順序是:先看自身的活動物件,找不到就往上找 a 的活動物件,再找不到就找 window,全都沒有則回傳 undefined。若 b 有 prototype,則在自身活動物件之後先查原型,再繼續往上。這就是 JavaScript 的變數查找機制。

四、兩個最基本的應用場景

  • 保護函式內的變數:上例中的 i 只有 b 能存取,外部沒有其他途徑,因此狀態被妥善保護。
  • 讓變數在記憶體中延續:因為閉包,a 中的 i 一直存在,每次呼叫 c() 都會在同一個 i 上做自增。

絕大多數經典閉包案例都源自這兩點。此外,JavaScript 沒有區塊級作用域,因此我們常用「立即執行函式 + 閉包」來製造私有變數,避免污染全域。

五、代價:記憶體與 GC

在 JavaScript 中,不再被引用的物件會被 GC 回收;兩個物件互相引用但無第三方引用時,也會被回收。正常情況下,函式開始執行時建立執行環境與作用域鏈,執行結束後就釋放它們。

function test() {
    var str = "hello world";
    console.log(str);
}
test();

但閉包打破了这个常態:由於閉包函式需要存取外層函式的變數,外層函式執行結束後,它的作用域活動物件並不會被釋放,而是被閉包函式的作用域鏈繼續引用;直到閉包函式本身被銷毀,那個活動物件才會跟著消失。這正是閉包佔用記憶體的原因。

所以閉包有好處也有壞處,濫用會造成可觀的記憶體消耗。特別是在迴圈中大量建立閉包、或讓閉包長期持有大型物件時,更應該留意。

六、經典陷阱:閉包只取到變數的最終值

(function ($) {
    var result = new Array(), i = 0;
    for (; i < 10; i++) {
        result[i] = function () {
            return i;
        };
    }
    $.RES1 = result;
})(jQuery);

$.RES1[0](); // 10,而不是期望的 0

這裡用匿名函式表達式開闢了一塊私有作用域,該匿名函式就是外層函式,它有一個參數 $,內部宣告了 result 與 i。迴圈替 result 的每個位置配置一個匿名函式,這些函式都存取了外層的 i,因此形成閉包。

問題在於:閉包存的是變數的引用,而不是當時的值。迴圈結束時 i 已經等於 10,所以無論呼叫哪一個函式,讀到的都是 10。

解法是再包一層,用立即執行函式把當下的 i 當作參數傳入,讓每個閉包各自綁定一個獨立的 num:

(function ($) {
    var result = new Array(), i = 0;
    for (; i < 10; i++) {
        result[i] = function (num) {
            return function () {
                return num;
            };
        }(i);
    }
    $.RES2 = result;
})(jQuery);

console.log($.RES2[0]()); // 0

另一個更常見的同類錯誤是替元素綁事件:

<div id="divTest">
  <span>0</span><span>1</span><span>2</span><span>3</span>
</div>

$(document).ready(function () {
    var spans = $("#divTest span");
    for (var i = 0; i < spans.length; i++) {
        spans[i].onclick = function () {
            alert(i); // 永遠是 4
        };
    }
});

同樣用 IIFE 修掉即可:

var spans2 = $("#divTest2 span");
$(document).ready(function () {
    for (var i = 0; i < spans2.length; i++) {
        (function (num) {
            spans2[i].onclick = function () {
                alert(num);
            };
        })(i);
    }
});

七、內部函式與它的「逃脫」

內部函式就是定義在另一個函式中的函式:

function outerFn() {
    function innerFn() { }
}

innerFn 被包在 outerFn 的作用域裡,因此在 outerFn 內部呼叫它是合法的,在外部呼叫則會出錯:

function outerFn() {
    document.write("Outer function<br/>");
    function innerFn() {
        document.write("Inner function<br/>");
    }
}
innerFn(); // Uncaught ReferenceError: innerFn is not defined

JavaScript 允許函式像任何資料一樣被傳遞,所以內部函式能夠「逃脫」定義它的外層函式。逃脫方式之一是把它指派給全域變數:

var globalVar;
function outerFn() {
    document.write("Outer function<br/>");
    function innerFn() {
        document.write("Inner function<br/>");
    }
    globalVar = innerFn;
}
outerFn();
globalVar();  // 等同於呼叫 innerFn
innerFn();    // 仍然 ReferenceError:名字只存在於 outerFn 的作用域中

另一種方式是用回傳值帶出引用:

function outerFn() {
    document.write("Outer function<br/>");
    function innerFn() {
        document.write("Inner function<br/>");
    }
    return innerFn;
}
var fnRef = outerFn();
fnRef();

這裡沒有修改任何全域變數,而是把 innerFn 的引用交給呼叫者保存。正因為即使離開了函式作用域,仍能透過引用呼叫內部函式,JavaScript 必須保留被引用的函式,並持續追蹤所有持有它的變數,直到最後一個變數消失,垃圾回收器才能釋放對應的記憶體。

八、變數作用域的實際行為

內部函式也可以有自己的區域變數,每次呼叫都會重新建立:

function outerFn() {
    function innerFn() {
        var innerVar = 0;
        innerVar++;
        document.write("innerVar = " + innerVar + "<br/>");
    }
    return innerFn;
}
var fnRef = outerFn();
fnRef(); // innerVar = 1
fnRef(); // innerVar = 1

若改成讀寫全域變數,則會持續累加:

var globalVar = 0;
function outerFn() {
    function innerFn() {
        globalVar++;
        document.write("globalVar = " + globalVar + "<br/>");
    }
    return innerFn;
}
var fnRef = outerFn();
fnRef(); // 1
fnRef(); // 2

而最關鍵的情況是讀寫父函式的區域變數:

function outerFn() {
    var outerVar = 0;
    function innerFn() {
        outerVar++;
        document.write("outerVar = " + outerVar + "<br/>");
    }
    return innerFn;
}
var fnRef = outerFn();
fnRef(); // outerVar = 1
fnRef(); // outerVar = 2

var fnRef2 = outerFn();
fnRef2(); // outerVar = 1
fnRef2(); // outerVar = 2

注意第二次呼叫 outerFn 並沒有延續之前的 2,而是從 1 重新開始。因為每次呼叫 outerFn 都會建立一個新的作用域,並在其中綁定一個新的 outerVar 實例,兩個計數器互不相關。

當內部函式在定義它的作用域之外被引用時,閉包就誕生了。 這些「既不是內部函式的區域變數、也不是它的參數」的變數被稱為自由變數,而外部函式的呼叫環境則稱為封閉閉包的環境。從本質上講,內部函式引用了外部函式的變數,等於授權那些變數延後使用,因此外部函式返回後,這些變數的記憶體不會被釋放。

九、多個閉包之間的共享環境

當一個外層函式回傳多個內部函式時,它們會共享同一個封閉環境:

function outerFn() {
    var outerVar = 0;
    function innerFn1() {
        outerVar++;
        document.write("Inner function 1: outerVar = " + outerVar + "<br/>");
    }
    function innerFn2() {
        outerVar += 2;
        document.write("Inner function 2: outerVar = " + outerVar + "<br/>");
    }
    return { "fn1": innerFn1, "fn2": innerFn2 };
}

var fnRef = outerFn();
fnRef.fn1(); // outerVar = 1
fnRef.fn2(); // outerVar = 3
fnRef.fn1(); // outerVar = 4

innerFn1 與 innerFn2 引用的是同一個 outerVar,因此其中一個改動後,另一個看到的是新值。這個結構其實非常類似物件導向:自由變數相當於實例屬性,閉包相當於實例方法,而且因為這些變數無法從封裝它們的作用域外部直接存取,它們天然就是私有的。對 outerFn 的下一次呼叫則會產生全新的閉包實例與全新的封閉環境。

十、回頭看那個 alert(4)

現在再來看開頭的例子就很清楚了:

for (var i = 0; i < spans.length; i++) {
    spans[i].onclick = function () { alert(i); };
}

頁面載入後這段程式立刻執行,迴圈結束時 i 等於 4。每個 span 的 onclick 都是內部函式,閉包以引用方式持有 i,因此 i 的記憶體無法被回收,值一直保持 4。點擊 span 時,onclick 沿作用域鏈查到 i,得到 4,於是就 alert 出 4。

而第二種寫法多包了一層立即執行函式:函式宣告放進括號後就變成表達式,後面再加一組括號即為呼叫。i 被當成參數傳入並立即執行,num 於是保存了每次迴圈當下的值,各自的閉包也就彼此獨立。

讀到這裡,閉包的全貌應該已經清楚。若還想再深入,把「執行環境」與「作用域鏈」這兩個機制弄透,所有關於閉包的疑問都能自行推導出來。

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