DIV CSS 佈局教程網

JavaScript 作用域與上下文完全解析
編輯:JavaScript基礎知識     

作用域(scope)與上下文(context)是 JavaScript 最具特色的設計之一,也是許多優雅設計模式得以成立的基礎。但正因為它們帶來的靈活性,反而讓不少開發者一頭霧水。本文試著把兩者的界線講清楚,並說明常見模式是如何運用它們的。

上下文不等於作用域

首先要澄清一個長期存在的誤解:上下文和作用域是兩回事,卻經常被混為一談。

每一次函數調用,同時伴隨著一個作用域和一個上下文。簡單記法是:作用域與函數有關,上下文與對象有關。作用域決定的是「這次調用能看到哪些變數」,每次調用彼此獨立;上下文則是關鍵字 this 的值,指向呼叫目前這段程式碼的所屬對象。

變數作用域

變數可以宣告在全域或區域。全域變數寫在函數體之外,整個執行期都存在,任何作用域都能讀寫;區域變數只在函數體內可見,每次呼叫都是一份全新的作用域,函數外部無法窺探。

過去 JavaScript 沒有區塊級作用域,也就是說寫在 if、switch、迴圈區塊裡的變數,出了區塊一樣拿得到。ES6 帶來的 let 改變了這件事——用 let 取代 var,宣告出來的區域變數就真正被關在區塊裡了。

this:由呼叫方式決定的上下文

當函數作為某個對象的方法被呼叫時,this 指向該對象:

var object = {
    foo: function () {
        alert(this === object);
    }
};

object.foo(); // true

用 new 建立實例時同理,this 會指向新產生的物件:

function foo() {
    alert(this);
}

foo();      // window
new foo();  // foo

如果是「裸呼叫」(沒有綁定在任何對象上),非嚴格模式下 this 會退回全域物件(瀏覽器裡就是 window);一旦開啟嚴格模式("use strict"),this 則會是 undefined。

執行上下文與作用域鏈

JavaScript 是單執行緒語言,瀏覽器中同一時間只能做一件事。直譯器開始執行時先進入全域上下文,之後每呼叫一次函數,就產生一個新的執行上下文。

這裡有個容易混淆的地方:「執行上下文(execution context)」這個術語指的其實是作用域,而不是前面談的上下文。命名確實糟糕,但既然 ECMAScript 規範這麼定,也只能照著用。

新建立的執行上下文會被疊到作用域鏈(有時也稱呼叫堆疊)最頂端,瀏覽器永遠執行最上面那一層。這一層跑完就彈出堆疊,控制權交回下一層。例如:

function first() {
    second();
    function second() {
        third();
        function third() {
            fourth();
            function fourth() {
                // do something
            }
        }
    }
}

first();

這段程式會一路嵌套呼叫到 fourth,此時作用域鏈由上而下是:fourth、third、second、first、global。fourth 能像用自己的變數一樣存取全域變數,以及 first、second、third 中宣告的變數。執行完畢後,fourth 的上下文被移出鏈頂,控制權回到 third,如此往上層遞退,直到全部程式碼跑完。

不同上下文之間的命名衝突,就靠沿作用域鏈向上查找來解決,由區域一路爬到全域。這意味著同名時,區域變數優先。

換句話說,每次要讀取某個變數,查找流程都是從目前上下文的變數物件開始;找不到就往作用域鏈上一層爬,逐層比對變數名稱,直到找到相符的值為止。

閉包

當一個內部函數在它的定義位置之外被取用,並且能在外部函數返回之後繼續執行,閉包就形成了。閉包讓內部函數保有對外部函數區域變數、arguments 與函數宣告的存取權。

封裝的價值在於:把執行上下文藏在外部作用域裡保護起來,只對外暴露一組公開介面。最簡單的例子:

function foo() {
    var local = 'private variable';
    return function bar() {
        return local;
    }
}

var getLocalVariable = foo();
getLocalVariable(); // private variable

最廣為人知的閉包應用莫過於「模組模式」,它能模擬公開、私有與特權成員:

var Module = (function () {
    var privateProperty = 'foo';

    function privateMethod(args) {
        // do something
    }

    return {
        publicProperty: "",

        publicMethod: function (args) {
            // do something
        },

        privilegedMethod: function (args) {
            privateMethod(args);
        }
    };
})();

它其實很接近單例:末尾那對括號讓函數在解釋完立刻執行。外界唯一能用的是回傳物件上的公開方法與屬性(例如 Module.publicMethod),而所有私有屬性與方法則在整個程式生命週期中存活,因為閉包把執行上下文保護了起來,任何互動都得經過公開介面。

另一種常見形式叫「立即調用函數表達式」(IIFE),本質上就是一個自呼叫的匿名函數:

(function (window) {

    var a = 'foo', b = 'bar';

    function private() {
        // do something
    }

    window.Module = {
        public: function () {
            // do something
        }
    };

})(this);

這種寫法對保護全域命名空間非常有用:函數體內宣告的一切都是區域變數,並靠閉包在整個執行期間持續存在。許多程式庫與框架都用這招包裝原始碼,只往外丟一個全域介面。

call、apply 與 bind

call 與 apply 是掛在每個函數上的內建方法,可以讓函數在自訂上下文中執行。差別只在參數形式:call 接受參數列表,apply 接受陣列。

function user(first, last, age) {
    // do something
}

user.call(window, 'John', 'Doe', 30);
user.apply(window, ['John', 'Doe', 30]);

兩種寫法效果相同:在 window 上下文中呼叫 user,並傳入同樣的三個參數。

ES5 另外提供了 Function.prototype.bind,它回傳一個新函數,其上下文被永久綁定到 bind 的第一個參數,日後無論怎麼呼叫都不會改變。它的實作正是靠閉包來「記住」上下文。以下是一份給舊瀏覽器的補丁:

if (!('bind' in Function.prototype)) {
    Function.prototype.bind = function () {
        var fn = this,
            context = arguments[0],
            args = Array.prototype.slice.call(arguments, 1);
        return function () {
            return fn.apply(context, args);
        }
    };
}

bind 最常被用來搶救「上下文遺失」的場合,例如物件導向程式與事件處理。之所以必要,是因為 addEventListener 會把回呼函數的上下文固定成綁定事件的節點。如果你寫的是較進階的物件導向結構,需要讓回呼函數的 this 維持在方法所屬實例上,就得手動校正:

function MyClass() {
    this.element = document.createElement('div');
    this.element.addEventListener('click', this.onClick.bind(this), false);
}

MyClass.prototype.onClick = function (e) {
    // do something
};

回頭看 bind 的實作,你會注意到這行:

Array.prototype.slice.call(arguments, 1);

值得留意的是,arguments 其實並不是陣列,只是常被描述為「類陣列(array-like)」物件,跟 document.getElementsByTagName() 回傳的 NodeList 類似。它們有 length、可以用索引取值,卻沒有 slice、push 這些原生陣列方法。不過正因為行為相似,我們可以把陣列方法「借」過來,在類陣列對象的上下文中執行。

同樣的技巧也出現在模擬傳統類繼承的時候:

MyClass.prototype.init = function () {
    // 在 MyClass 實例的上下文中呼叫父類的 init
    MySuperClass.prototype.init.apply(this, arguments);
}

在子類實例的上下文裡呼叫父類方法,就能重現這個強而有力的設計模式。

結語

在深入學習高階設計模式之前,先把作用域與上下文搞透,是非常值得的投資。無論談的是閉包、物件導向、繼承,還是各種原生實作,這兩個概念都在幕後扮演關鍵角色。若你的目標是真正吃透 JavaScript,它們就是最好的起點。

補充:作者版本的 bind 並不完整

原文給的 bind 有個缺陷——呼叫 bind 之後產生的函數時,無法再傳入額外參數。下面這個小修正解決了問題:

if (!('bind' in Function.prototype)) {
    Function.prototype.bind = function () {
        var fn = this,
            context = arguments[0],
            args = Array.prototype.slice.call(arguments, 1);
        return function () {
            return fn.apply(context, args.concat(arguments)); // fixed
        }
    };
}
XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved