DIV CSS 佈局教程網

JavaScript 必知必會(九):從 function 談到閉包
編輯:關於JavaScript     

閉包是 JavaScript 面試的必考題,但要真正吃透它,得先把作用域鏈與變數宣告規則弄明白。

函式的三個關鍵屬性

function getPropNames(o, /*optional*/ a) {
    a = a || [];
    for (var p in o) {
        a.push(p);
    }
    return a;
}

caller 回傳呼叫者函式:

function callfunc() {
    if (callfunc.caller) {
        alert(callfunc.caller.toString());
    } else {
        alert("沒有函式呼叫");
    }
}
function handleCaller() { callfunc(); }

handleCaller();     // 顯示 handleCaller 的內容
callfunc();         // 沒有呼叫者,印出「沒有函式呼叫」

callee 讓匿名函式能自我遞迴:

alert((function (x) {
    if (x <= 1) return 1;
    return x * arguments.callee(x - 1);
}(5)));   // 120,等於 5!

作用域的基本規則

全域變數在函式內部可以存取;當區域變數與全域變數同名時,區域變數會遮蔽全域變數,且不會破壞全域的值。

var scope = "global scope";

function f() {
    var scope = "local scope";
    return scope;
}

alert(f());     // local scope
alert(scope);   // global scope

區域變數一定要用 var 宣告。少了 var,在非嚴格模式下它會變成全域變數:

scope = "global scope";

function f() {
    scope = "local scope";   // 少了 var!
    return scope;
}

alert(f());     // local scope
alert(scope);   // local scope,全域被污染了

在嚴格模式下這會直接丟出錯誤:

"use strict";
scope = "global scope";   // ReferenceError

所以,宣告變數時千萬不要省略 var(或 let/const),這能省掉一堆找不出原因的 bug。

宣告會被提前(hoisting)

"use strict";
scope;
console.log(scope);         // undefined

var scope = "global scope";
console.log(scope);         // global scope

為什麼在宣告之前就能讀取而不報錯?這要從作用域鏈說起。

作用域鏈

JavaScript 是基於詞法作用域的語言。作用域鏈是一串物件組成的鏈表,記錄了該段程式碼「作用域中」的所有變數。當引擎需要查找 scope 時,會從鏈中第一個物件開始找,找到就回傳;找不到就往下一個物件找,直到鏈尾。若一路都找不到,才丟出錯誤。

所以上面那段程式碼的查找路徑是:scope → window(全域物件)。宣告已被提前,但賦值還沒發生,因此值是 undefined。

一個容易答錯的題目

"use strict";
var scope = "global scope";

function f() {
    console.log(scope);
    var scope = "local scope";
    console.log(scope);
}

f();

許多人會回答「先印 global scope,再印 local scope」,理由是函式一開始看到的是全域變數,後來才被區域變數覆蓋。這個推理在 C#、Java 中完全正確,但在 JavaScript 中是錯的。

關鍵這句話請記住:全域變數在整個程式中始終有定義;區域變數在宣告它的函式體以及其內嵌的函式內,始終是有定義的。因此函式裡的 var scope 從函式第一行起就存在,只是尚未賦值——兩個 console.log 分別印出 undefined 與 local scope。

另一個例子更反直覺:

var g = "global scope";

function f() {
    for (var i = 0; i < 3; i++) {
        for (var j = 0; j < 3; j++) { }
        console.log(j);
    }
    console.log(i);
}

console.log(g);
f();

許多人以為 {} 區塊結束後 i、j 就會被回收,結果應該是 undefined。實際輸出卻是 3 和 3——因為 JavaScript(ES6 之前)只有函式作用域,沒有區塊作用域,var 宣告的變數整個函式內都有效。

順帶一提,函式的參數也屬於區域變數的範疇,這一點同樣重要。

作用域鏈的組成

1. 作用域鏈始終由全域物件收尾。
2. 在不包含嵌套的函式體內,作用域鏈上有兩個物件:第一個存放函式參數與區域變數,第二個是全域物件。
3. 在嵌套的函式體內,作用域鏈至少包含三個物件。

定義函式時會保存一份作用域鏈;呼叫函式時,引擎會建立新物件存放區域變數,把它接到保存的鏈上,形成更長的作用域鏈。對嵌套函式而言,每次呼叫外部函式都會重新定義內部函式,兩者的程式碼相同,但關聯的作用域各不相同。

閉包登場

先看一個依作用域鏈追值的例子:

var nameg = "global";

var g = function f() {
    console.log(name);
    var name = "f-scope";

    function demo0() { console.log("demo0=" + name); }
    function demo1() { var name = "demo1-scope"; console.log("demo1=" + name); }
    function demo2() { console.log("demo2=" + nameg); }

    demo0(); demo1(); demo2();
};
g();

依鏈查找:demo0 在自己身上找不到 name,往 f 找到,印出 f 作用域的值;demo1 找到自己區域的 name;demo2 找 nameg,自身沒有、f 沒有、往 window 找到。

接著看閉包最典型的樣貌——計數器:

function f() {
    var count = 0;
    return {
        counter: function () { return count++; },
        reset: function () { return count = 0; }
    };
}

var d = f();
var c = f();

console.log("d 第一次呼叫:" + d.counter());   // 0
console.log("c 第一次呼叫:" + c.counter());   // 0,互不影響
console.log("d 重置:" + d.reset());           // 0
console.log("c 第二次呼叫:" + c.counter());   // 1

d 與 c 各自持有獨立的作用域鏈,所以互不干擾;而 c 第二次呼叫時 count 仍記得上次的值,因為 c 這個物件並未被回收,它引用的 count 也就活了下來。這就是閉包的本質:函式連同它被定義時所處的作用域一起被保留。

經典的迴圈陷阱

function btnInit() {
    for (var i = 0; i < 4; i++) {
        var btn = document.getElementById("btn" + i);
        btn.addEventListener("click", function () {
            alert("btn" + i);
        });
    }
}
window.onload = btnInit;

四顆按鈕,點下去卻全部顯示 btn4。原因用作用域鏈一分析就清楚:點擊時才執行匿名函式 → 自身找不到 i → 往 btnInit 找,此時迴圈早已結束,i 停在最終值。

解法是用一層立即呼叫的函式把 i 的當前值固定下來:

function btnInit() {
    for (var i = 0; i < 4; i++) {
        (function (data_i) {
            var btn = document.getElementById("btn" + data_i);
            btn.addEventListener("click", function () {
                alert("btn" + data_i);
            });
        }(i));
    }
}

每輪迴圈都建立一個新的作用域,data_i 各自綁定當下的 i,互不影響,結果就正確了。若使用 ES6,直接把迴圈變數改成 let 也能達到同樣效果,因為 let 天生具備區塊作用域。

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