DIV CSS 佈局教程網

JavaScript 閉包、作用域鏈與記憶體洩露筆記
編輯:關於JavaScript     

閉包是 JavaScript 的難點,也是它的特色——許多進階用法都得靠它實現。這篇把閉包、作用域鏈、垃圾回收與記憶體洩露串成一份筆記。

一、閉包的三個特性

1. 函式中嵌套函式。

2. 內部函式可以引用外部的參數與變數。

3. 被引用的參數與變數不會被垃圾回收機制回收。

二、定義與代價

閉包指的是有權存取另一個函式作用域中變數的函式。最常見的建立方式,是在一個函式內定義另一個函式,透過它去存取外層的區域變數。

閉包的缺點也很明確:它讓變數常駐記憶體,增加記憶體用量,使用不當就會造成洩露。它的主要價值則在於模擬私有方法與私有變數。

一般函式執行完畢後,區域的活動物件會被銷毀,記憶體中只留全域作用域;閉包則不然。

幾種常見的定義說法:

有權存取另一個函式作用域中變數的函式。

函式物件透過作用域鏈相互關聯,函式體內部的變數保存在函式作用域內,這種特性稱為閉包。

內部函式可以存取定義它們的外部函式的參數與變數(this 與 arguments 除外)。

歸納起來就兩句:能存取外部函式作用域中變數的函式;被內部函式引用的外部變數會留在作用域中而不被回收。後者才是核心——分析任何閉包問題時,都要先找出「被引用的是哪個變數」。

var sayName = function(){
    var name = 'jozo';
    return function(){
        alert(name);
    }
};
var say = sayName();
say();

逐句解讀:

var say = sayName() —— 回傳的匿名內部函式被存進 say,而它引用了外層的 name。由於這個引用存在,sayName 執行完畢後 name 並沒有被回收。

say() —— 執行內部函式,仍能讀到 name,輸出 'jozo'。

三、作用域鏈

理解作用域鏈,是理解閉包的關鍵。變數的查找方式就是沿著作用域鏈往上找。

函式被呼叫時會發生兩件事:建立執行環境與對應的作用域鏈;把 arguments 與其他命名參數的值加入函式的活動物件(activation object)。

作用域鏈的優先順序是:當前函式的活動物件最高,外層函式次之,再往外層遞減,直到末端的全域作用域。這個順序決定了變數查找時誰先被找到。

先看一個沒有閉包的例子:

function sayName(name){
    return name;
}
var say = sayName('jozo');

這段程式有兩個作用域:全域作用域,以及 sayName 函式的作用域,合共兩個變數物件。執行到對應的執行環境時,該變數物件會成為活動物件,被推到作用域鏈前端,也就是最高優先。

建立 sayName() 時,會先產生一條包含全域變數物件的作用域鏈,存進函式內部的 [[Scope]] 屬性。呼叫 sayName() 時,建立執行環境,複製 [[Scope]] 中的物件構成作用域鏈,接著又建立一個活動物件並推到前端。

函式執行完畢後,區域活動物件通常就被銷毀,記憶體只留全域作用域。閉包的情況不同:

function sayName(name){
    return function(){
        return name;
    }
}
var say = sayName('jozo');

這個例子多了一層匿名函式的作用域。匿名函式被回傳後,它的作用域鏈被初始化為「sayName() 的活動物件 + 全域物件」。因此它能讀到 sayName() 中所有變數與參數;更關鍵的是,sayName() 執行完畢後,它的活動物件不會被銷毀——因為匿名函式的作用域鏈仍引用著它。sayName() 的執行環境會解體,但活動物件會留在記憶體中,直到匿名函式本身被回收。這正是後面要談的記憶體洩染來源。

四、兩個實作範例

範例一:累加計數

// 方式1
var a = 0;
var add = function(){
    a++;
    console.log(a);
}
add();
add();

// 方式2:閉包
var add = (function(){
    var a = 0;
    return function(){
        a++;
        console.log(a);
    }
})();
add();
add();

方式二更優雅,也減少了全域變數,把 a 私有化了。

範例二:為每個 li 加上點擊事件

var oli = document.getElementsByTagName('li');
var i;
for(i = 0; i < 5; i++){
    oli[i].onclick = function(){
        alert(i);
    }
}
console.log(i); // 5

點下去永遠彈出 5,為什麼?因為迴圈結束後 i 已經變成 5,而每個 onclick 裡的匿名函式引用的都是同一個變數 i。等到使用者實際點擊時,讀到的自然是最終值。

用閉包就能解決:

var oli = document.getElementsByTagName('li');
var i;
for(i = 0; i < 5; i++){
    oli[i].onclick = (function(num){
        var a = num;   // 為了說明問題
        return function(){
            alert(a);
        }
    })(i);
}
console.log(i); // 5

這裡每輪迴圈都會立即執行外層的匿名函式,把當前 i 當作參數傳入。由於參數是「按值傳遞」,形參 num 保存的是那一輪 i 的實際數值,再複製給區域變數 a。回傳的內部函式持續引用各自的 a,因此五個 li 各自記住了 0 到 4。迴圈結束後 i 依然是 5,但那已與每個 a 無關。

當然,現在有更簡潔的寫法。用 let 讓每輪迴圈擁有自己的綁定即可:

var oli = document.getElementsByTagName('li');
for(let i = 0; i < oli.length; i++){
    oli[i].onclick = function(){ alert(i); };
}

或用 const 搭配 forEach:

Array.prototype.forEach.call(
    document.getElementsByTagName('li'),
    function(li, i){
        li.onclick = function(){ alert(i); };
    }
);

閉包式寫法在 ES2015 之前是唯一解,理解它仍有價值——畢竟 let 底層做的正是類似的事:為每次迭代建立新的作用域。

五、閉包的實際用途

1. 匿名自執行函式

有些函式只需執行一次,內部變數不必維護,例如 UI 初始化:

//將全部li字體變為紅色
(function(){
    var els = document.getElementsByTagName('li');
    for(var i = 0, lng = els.length; i < lng; i++){
        els[i].style.color = 'red';
    }
})();

外部無法引用其內部變數,因此 els、i、lng 執行完後很快就被釋放,節省記憶體,也不會污染全域物件。

2. 封裝與模組化

var person = function(){
    //變量作用域為函數內部,外部無法訪問
    var name = "default";
    return {
        getName : function(){ return name; },
        setName : function(newName){ name = newName; }
    }
}();

console.log(person.name);        // undefined,直接存取不到
console.log(person.getName());   // default
person.setName("jozo");
console.log(person.getName());   // jozo

name 被兩個方法閉包住,外部只能透過方法存取——這就是模組模式(Module Pattern)的核心,也是揭示模組(Revealing Module Pattern)的基礎。

3. 模擬物件

JavaScript 沒有 class 機制,但靠閉包可以讓不同實例擁有獨立且互不干擾的狀態:

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

var person1 = Person();
person1.setName("person1");
print(person1.getName());   // person1

var person2 = Person();
person2.setName("person2");
print(person2.getName());   // person2

兩個實例各自持有獨立的 name,因為每次呼叫 Person() 都會產生新的區域變數與新的閉包。原始範例中把 person1 寫成 john、person2 寫成 jack,會直接 ReferenceError,這裡已修正為一致的變數名稱。

六、垃圾回收與記憶體洩露

談記憶體管理,離不開垃圾回收機制。實作上有兩種策略:標記清除與引用計數。

標記清除:垃圾收集器執行時,先替記憶體中所有變數加上標記,接著移除環境中變數以及被環境中變數所引用之變數的標記。此後仍帶著標記的變數,即代表準備被刪除。截至 2008 年,IE、Firefox、Opera、Chrome、Safari 的 JavaScript 引擎都採用這個方式。

引用計數:追蹤每個值被引用的次數。宣告變數並指派一個引用型別的值時,該值計數為 1;再指派給另一個變數則加 1;變數脫離引用則減 1;歸零時等待回收。

引用計數有個大問題:循環引用。若物件 A 有一個指向 B 的指標,B 也有一個指向 A 的引用,兩者的計數永遠不會歸零,記憶體因此無法回收。早期 IE(IE4–IE6)用的正是計數機制,這是閉包導致洩露的一個成因。

更麻煩的是,IE 中有一部分物件並非原生的 JavaScript 物件——BOM 與 DOM 中的物件是以 COM 物件形式實作的,而 COM 物件用的就是引用計數。因此即使 IE 的 JS 引擎採用標記清除,只要涉及 COM 物件,循環引用的問題依然存在。

典型例子:

window.onload = function(){
    var el = document.getElementById("id");
    el.onclick = function(){
        alert(el.id);
    }
}

為什麼會洩露?把匿名函式指派給 el 的 onclick 屬性後,該函式內部又引用了 el,形成循環引用:DOM 元素持有函式,函式又持有 DOM 元素,兩邊計數都不為零,谁也回收不了。

解法是主動切斷其中一端:

window.onload = function(){
    var el = document.getElementById("id");
    var id = el.id;      // 取出需要的值

    el.onclick = function(){
        alert(id);       // 只引用 id,不再引用 el
    };

    el = null;           // 清除閉包引用的外部活動物件
}

兩個動作各有作用:讓匿名函式不再引用 el,循環就此中斷;再把 el 設為 null,釋放外層活動物件對它的引用。

實務上,如果你已經不必支援 IE6 這類古董瀏覽器,這個特定問題就不存在——現代引擎一律使用標記清除。但閉包造成的記憶體累積仍是真實的:只要閉包存在,它引用的所有變數都無法回收。常見的肇因包括:被遗忘的計時器(setInterval 未 clearInterval)、未移除的事件監聽器(尤其處理函式閉包住大物件時)、以及持續增長卻從未清理的陣列或快取。

因此撰寫時可以留意幾個習慣:不需要長期存活的閉包,執行完就把引用放掉;元件卸載時記得 clearInterval、removeEventListener;快取要設上限或失效策略。想確認實際狀況,用 DevTools 的 Memory 面板拍兩次快照比對,比憑感覺猜測可靠得多。

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