DIV CSS 佈局教程網

深入淺析 JavaScript 中的作用域與上下文
編輯:關於JavaScript     

作用域(scope)與上下文(context)堪稱 JavaScript 最有個性的設計,也是它靈活性的來源。每個函數都有各自的變量上下文與作用域,這些機制支撐起了許多強大的設計模式。但正因為靈活,它也讓不少開發者(包括我自己早期)栽過跟頭。下面把這兩個概念徹底分清楚。

一、先明確:這是兩個完全不同的概念

很多術語在社區裡被混用,作用域和上下文就是重災區。一句話概括:

· 作用域基於函數,關心的是「這個函數裡能訪問到哪些變量」。
· 上下文基於對象,就是 this 的值,指向當前執行代碼所歸屬的那個對象。

每次函數調用都同時涉及這兩者,但它們解決的問題完全不同。

二、變量作用域

變量可以定義在局部或全局作用域,這決定了它在運行期間的可訪問範圍。全局變量聲明在函數體之外,作用於整個運行時,任何作用域都能讀取。局部變量則局限於函數體內,每次調用都有獨立的一份。

關鍵在於:ES6 之前 JavaScript 沒有塊級作用域。if 語句、switch、for、while 的花括號並不會產生新作用域,這與 Java 等語言的直覺完全不同。

// ES6 之前:var 存在變量提升,循環外仍能訪問
function func() {
  if (true) {
    var tmp = 123;
  }
  console.log(tmp);   // 123
}
// ES6 之後:let 支持塊級作用域
function func() {
  if (true) {
    let tmp = 123;
  }
  console.log(tmp);   // ReferenceError: tmp is not defined
}

用 let(以及 const)替代 var,能在編譯階段就攔住一大批因變量提升引發的隱患。

三、this 到底指向誰

上下文取決於函數如何被調用。作為對象方法調用時,this 指向該對象:

var obj = {
  foo: function () { alert(this === obj); }
};
obj.foo();   // true

用 new 調用時,this 指向新創建的實例;而普通直接調用時,非嚴格模式下 this 指向全局對象(瀏覽器中即 window),ES5 嚴格模式下則為 undefined:

function foo() { alert(this); }
new foo();   // foo
foo();       // window(非嚴格模式)

四、執行環境(Execution Context)

JavaScript 是單線程語言,同一時間只執行一個任務。解釋器開始執行程式碼時,先進入默認的全局執行環境,此後每次函數調用都會創建一個新的執行環境。

這裡的術語特別容易讓人暈:執行環境(execution context)定義了變量或函數有權訪問的其他數據,決定它們各自的行為,作用更接近我們前面說的「作用域」,而不是上下文(context)。這個命名約定確實糟糕,但它是 ECMAScript 規範定的,只能遵守。

每個函數都有自己的執行環境。進入函數時,其環境被推入環境棧;函數執行完畢後棧把環境彈出,控制權交還給上一層。ECMAScript 的執行流正是靠這個機制調度。

執行環境分為創建與執行兩個階段。創建階段解析器會建立變量對象(variable object,也稱活動對象),收集其中定義的變量、函數聲明與參數,同時初始化作用域鏈並確定 this 的值;執行階段才真正逐行解釋代碼。需要注意的是,這個變量對象我們無法在代碼中直接訪問,只有解析器能操作它。

五、作用域鏈

代碼在某個環境中執行時,會創建變量對象的作用域鏈,用於保證對執行環境有權訪問的所有變量和函數能被有序查找。它包含了環境棧中每個執行環境對應的變量對象,其中全局執行環境的變量對象永遠排在鏈的末尾。

var color = "blue";

function changeColor() {
  var anotherColor = "red";

  function swapColors() {
    var tempColor = anotherColor;
    anotherColor = color;
    color = tempColor;
    // 這裡可以訪問 color、anotherColor、tempColor
  }

  // 這裡可以訪問 color、anotherColor,但訪問不到 tempColor
  swapColors();
}

changeColor();
// 這裡只能訪問 color
console.log("Color is now " + color);

上述程式碼有三個執行環境:全局環境、changeColor 的局部環境、swapColors 的局部環境。從上圖可以看出:內部環境可以通過作用域鏈訪問所有外部環境,外部環境卻無法訪問內部環境的任何變量與函數。這些環境之間的聯繫是線性且有次序的。

標識符解析(搜尋變量名或函數名)正是沿著這條鏈進行的:始終從作用域鏈前端開始,逐級向後回溯至全局環境,直到找到為止;若一直到末尾都沒找到,便判定為未定義。

六、閉包

閉包是指有權訪問另一個函數作用域中變量的函數。在函數內定義嵌套函數,就構成了閉包,它讓內層函數得以讀取外層函數的變量。通過返回嵌套函數,你可以在隱藏執行環境細節的同時,暴露一個公共接口供外部操作。

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

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) {
      return privateMethod(args);
    }
  };
})();

它類似一個單例。由於用了 (function(){...})(); 這種立即調用形式,解析時便會執行一次。外部唯一能接觸到的,只有返回對象裡的公開方法與屬性;而因為執行上下文被閉包保留,私有屬性與方法會在整個生命週期內持續存在,只能通過公共方法間接交互。

另一種常見形式是立即執行函數表達式(IIFE),本質就是一個在全局環境中自執行的匿名函數:

(function (window) {
  var foo, bar;

  function private() {
    // do something
  }

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

它通過函數作用域把內部變量與全局命名空間隔離,再借助閉包讓它們在整個運行期存活,只暴露一個單一的全局接口對外交互。許多庫與框架都採用這種方式組織源代碼。

七、call 與 apply

這兩個方法內建於所有函數(掛在 Function.prototype 上),可以讓你在自定義上下文中執行函數。區別只在參數形式:call 需要逐一列舉參數,apply 接受一個數組。

var o = {};

function f(a, b) { return a + b; }

f.call(o, 1, 2);     // 3
f.apply(o, [1, 2]);  // 3

兩次調用等價:函數 f 在對象 o 的上下文中執行,並收到相同的兩個參數。

ES5 新增了 Function.prototype.bind,它會返回一個新函數,且這個新函數的 this 被永久綁定到 bind 的第一個參數上,無論後續如何調用都不再改變。它本質上是用閉包把函數「導航」到正確的上下文。對低版本瀏覽器可以簡單 polyfill:

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));
    };
  };
}

bind 最典型的用途是修復上下文丟失。比如 addEventListener 會讓回調在「被綁定的那個節點」的上下文中執行,這本是它應有的行為;但當你想在回調裡訪問某個類實例時,就需要手動校正:

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

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

回顧 bind 的 polyfill,可以注意到兩處對 slice 的借用:

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

arguments 並不是真正的數組,只是類數組對象——它有 length、支持下標訪問,卻沒有 slice、push 這些原生方法。但因為行為相似,數組方法可以被「劫持」過來使用,核心正是 call/apply 提供的上下文改變能力。

這門技巧同樣可以用於面向對象,在 JavaScript 中模擬經典繼承:

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

八、ES6 箭頭函數

箭頭函數可以視為 Function.prototype.bind() 的一種替代方案。與普通函數不同,它沒有自己的 this,this 直接沿用外圍作用域的值。

普通函數則總會自動接收一個 this,指向何處取決於調用方式。看一個典型場景:

var obj = {
  addAll: function (pieces) {
    var self = this;
    _.each(pieces, function (piece) {
      self.add(piece);
    });
  }
};

最直接的想法是寫 this.add(piece),但不幸的是回調函數並不會從外層繼承 this,此時它是 window 或 undefined,所以只能用 self 這個臨時變量把外層 this「搬」進來。另外還有兩種更優雅的解法:

// 方案一:ES5 的 bind
var obj = {
  addAll: function (pieces) {
    _.each(pieces, function (piece) {
      this.add(piece);
    }.bind(this));
  }
};
// 方案二:ES6 箭頭函數
var obj = {
  addAll: function (pieces) {
    _.each(pieces, piece => this.add(piece));
  }
};

箭頭函數版本中,addAll 從調用者處獲得 this,內部箭頭函數自動繼承了它,代碼更乾淨。

順帶提醒一個差異:回調函數裡的 this,在瀏覽器中為 window(嚴格模式下為 undefined),而在 Node.js 中為 global。示例:

function hello(a, callback) {
  callback(a);
}

hello('weiwei', function (a) {
  console.log(this === global);   // Node 環境下為 true
  console.log(a);                 // weiwei
});

九、小結

在學習高級設計模式之前,把作用域與上下文吃透非常重要。無論是閉包、面向對象、繼承還是各種原生實現,這兩個概念都在其中扮演基礎角色。如果你的目標是真正精通 JavaScript,它們就是最好的起點。

一張速查表幫助記憶:作用域管變量可見性,由函數與塊決定,通過作用域鏈向上查找;上下文管 this 指向,由調用方式決定,可通過 call/apply/bind 或箭頭函數干預;執行環境是代碼運行的容器,有創建與執行兩階段,並以棧的形式組織。

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