DIV CSS 佈局教程網

JavaScript 閉包入門:概念、陷阱與實用場景
編輯:關於JavaScript     

如果對作用域、以及「函式是獨立物件」這兩個概念已經理解得夠清楚,那麼閉包對你來說會有一種水到渠成的感覺。否則它往往顯得撲朔迷離。

在 DOM 事件處理的場景裡,多數開發者其實早已不知不覺在用閉包了。這種「用了卻不確定自己在用什麼」的狀態,正是 bug 與記憶體洩漏的溫床。

一句話定義

在 JavaScript 中,函式是物件,物件是屬性的集合,屬性的值又可以是物件——所以在函式內部定義函式是完全合理的。當你在函式 func 內部宣告了一個 inner 函式,然後在 func 外部呼叫 inner,這個過程就產生了一個閉包。

閉包的第一個陷阱

先看一個例子,不了解 JavaScript 特性很難看出問題:

var outter = [];
function clouseTest() {
    var array = ["one", "two", "three", "four"];
    for (var i = 0; i < array.length; i++) {
        var x = {};
        x.no = i;
        x.text = array[i];
        x.invoke = function () {
            print(i);
        }
        outter.push(x);
    }
}
clouseTest();
print(outter[0].invoke());
print(outter[1].invoke());
print(outter[2].invoke());
print(outter[3].invoke());

初學者大概會回答 0、1、2、3。實際跑出來的結果卻是:

4
4
4
4

原因在于:迴圈每次迭代時,x.invoke = function(){ print(i); } 並沒有真的執行,它只是建立了一個函式物件,函式體是 print(i)。而閉包引用的是變數本身,不是建立當時的值。迴圈結束後 i 變成 4,所以四個 invoke 呼叫時讀到的都是 4。

解法是用立即執行函式把當下的值固定下來:

var outter = [];
function clouseTest2() {
    var array = ["one", "two", "three", "four"];
    for (var i = 0; i < array.length; i++) {
        var x = {};
        x.no = i;
        x.text = array[i];
        x.invoke = function (no) {
            return function () {
                print(no);
            }
        }(i);
        outter.push(x);
    }
}
clouseTest2();

這裡為 x.invoke 赋值時,先執行一個「會回傳函式」的外層函式並立即呼叫,把當下的 i 當作參數傳入。於是每次迭代等同於分別寫了:

// x == 0
x.invoke = function () { print(0); }
// x == 1
x.invoke = function () { print(1); }
// x == 2
x.invoke = function () { print(2); }
// x == 3
x.invoke = function () { print(3); }

如果環境支援 ES6,直接用 let 宣告迴圈變數就能解決,因為 let 每次迭代都會建立新的綁定:for (let i = 0; ...)。

歸納成一句話:閉包允許你引用外部函式中的變數,但它取用的是該變數最後的值,而不是建立時的值。

用途一:模擬私有變數與封裝

閉包最實用的能力,是讓變數真正「藏起來」:

var person = function () {
    // 變數作用域為函式內部,外部無法訪問
    var name = "default";

    return {
        getName : function () {
            return name;
        },
        setName : function (newName) {
            name = newName;
        }
    }
}();

print(person.name);       // 直接訪問,結果為 undefined
print(person.getName());  // default
person.setName("jack");
print(person.getName());  // jack

輸出結果:

undefined
default
jack

JavaScript 沒有 private 關鍵字,但透過閉包可以做到同樣的效果:外部只能透過你開放的 getName / setName 存取 name,無法直接竄改。

用途二:模擬傳統的物件語意

傳統物件語言提供 class 模板機制,讓不同實例擁有獨立且互不干擾的狀態。JavaScript 沒有 class(ES6 之前),但閉包可以模擬出來。把上面的例子改成建構函式:

function Person() {
    var name = "default";

    return {
        getName : function () {
            return name;
        },
        setName : function (newName) {
            name = newName;
        }
    }
};
var john = Person();
print(john.getName());
john.setName("john");
print(john.getName());

var jack = Person();
print(jack.getName());
jack.setName("jack");
print(jack.getName());

輸出:

default
john
default
jack

兩個實例的 name 各自獨立,因為每次呼叫 Person() 都會建立一個新的作用域與新的 name 變數。

用途三:快取

閉包不會釋放對外部變數的引用,所以函式內的值得以在多次呼叫之間保留。這正好可以用來做快取:

var CachedSearchBox = (function () {
    var cache = {},
        count = [];
    return {
        attachSearchBox: function (dsid) {
            if (dsid in cache) {          // 如果結果在緩存中
                return cache[dsid];       // 直接返回緩存中的對象
            }
            var fsb = document.getElementById(dsid);  // 新建
            cache[dsid] = fsb;                        // 更新緩存
            if (count.length > 100) {                 // 保證緩存大小 <= 100
                delete cache[count.shift()];
            }
            return fsb;
        },
        clearSearchBox: function (dsid) {
            if (dsid in cache) {
                cache[dsid].clearSelection();
            }
        }
    };
})();

var obj1 = CachedSearchBox.attachSearchBox("input1");
var obj2 = CachedSearchBox.attachSearchBox("input1");

obj1 與 obj2 會是同一個物件參照,第二次呼叫完全沒有 DOM 查詢的開銷。

必須注意的三個問題

1. 記憶體洩漏

不同 JavaScript 引擎的實作各有缺陷,使用閉包可能造成記憶體洩漏。這對瀏覽器響應速度影響明顯,嚴重時會導致無回應。

原理是這樣的:多數引擎採用引用計數做垃圾回收,計數歸零就回收。但閉包中的區域變數因為可能被未來的某次呼叫使用,回收機制不會處理它們。若再加上循環引用(A 引用 B、B 引用 C、C 又引用 A),引用計數永遠大於零,記憶體就洩漏了。特別是在 IE 中,DOM 元素與 JS 物件之間的循環引用是經典案例。

2. this 的上下文陷阱

這個例子很容易判斷錯:

$(function () {
    var con = $("div#panel");
    this.id = "content";
    con.click(function () {
        alert(this.id);   // panel
    });
});

很多人會根據閉包概念推論結果是 "content"——理由是 this.id 被設為 content,而 click 回呼形成閉包,應該能引用到 this.id。實際弹出的卻是 "panel"。

原因在于:閉包確實能引用區域變數,但 this 是特殊的。事件觸發時,瀏覽器會以觸發事件的元素作為 this 呼叫該處理函式,所以這裡的 this 指向觸發 click 的那個 panel 元素。而外層的 this.id = "content" 是對 ready 回呼本身的 this 操作,兩者根本不是同一個物件。

要繞過這個問題,先把 this 存成區域變數:

$(function () {
    var con = $("div#panel");
    this.id = "content";
    var self = this;
    con.click(function () {
        alert(self.id);   // content
    });
});

這樣事件處理函式引用的是區域變數 self,而不是會被重新指派的 this。這個 var self = this 或 var that = this 的技巧在實務中到處可見,ES6 的箭頭函式則從語法層面直接解決了它。

3. 迴圈中的變數捕獲

前面已經示範過:閉包取用變數的最後值。除了 IIFE 與 let,另一個常見做法是透過 Function.prototype.bind 建立帶參數的新函式。

總結

閉包不是什麼高深莫測的東西,它就是「函式 + 它所能看到的外部作用域」。真正的難點在於理解它的取值時機與 this 行為,並在使用時意識到記憶體代價。掌握這三點,閉包就會從一個容易出錯的陷阱,變成你工具箱裡最靈活的一把扳手。

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