DIV CSS 佈局教程網

JavaScript 模塊化實踐:用閉包做封裝,用原型做繼承
編輯:JavaScript綜合知識     

JavaScript 天生一副隨隨便便的樣子,但隨著瀏覽器承擔的工作越來越重,這門語言也越來越常需要正襟危坐。邏輯一複雜,模塊化就成了必然選擇:把實現細節藏起來,只暴露一組供外界調用的接口。閉包正是實現這層封裝的關鍵,也是不少初學者卡住的地方。本文嘗試從一個極小的計數器對象出發,把這條路走一遍。

需求:一個只能加、不能改的計數器

假設頁面上要維護一個計數器 ticker,內部保存數值 n。用戶操作可以讓計數加一,但不允許減少,也不允許直接改寫 n;同時需要隨時查詢當前數值。

第一種寫法:門戶大開的 JSON 風格

var ticker = {
  n: 0,
  tick: function () {
    this.n++;
  }
};

這種寫法自然流暢,也确实能跑:加一次就 ticker.tick(),查數值就讀 ticker.n。但缺點一目瞭然——使用者可以隨意寫 ticker.n-- 甚至 ticker.n = -1。n 和 tick() 看似是 ticker 的「成員」,可訪問性卻和 ticker 一樣是全局的。相比下面這種更極端的寫法,它的封裝性只好那麼一點點(雖然對簡單場景來說這點也夠了):

var ticker = {};
var tickerN = 0;
var tickerTick = function () {
  tickerN++;
};

tickerTick();

順帶一提,tick() 裡之所以寫 this.n,並不是因為 n 是 ticker 的成員,而是因為當前的調用者是 ticker。寫成 ticker.n 反而更穩妥,因為一旦調用者換了人:

var func = ticker.tick;
func();

此時 this 指向 window,函數會去訪問 window.n 然後出錯。

事實上這種「門戶大開」的結構更適合用來組織 JSON 數據,而不是程序邏輯。比如我們可以傳一個配置對象進去,讓 ticker 從 100 開始、每次遞進 2:

var config = {
  nStart: 100,
  step: 2
};

作用域鏈與閉包登場

把 ticker 從對象改成函數,情況就完全不同了:

function ticker(config) {
  var n = config.nStart;
  function tick() {
    n += config.step;
  }
}
console.log(ticker.n); // -> undefined

為什麼從對象變成了函數?因為 JavaScript 中只有函數才創造作用域,函數外部無法訪問其內部變量。從 tick() 到 ticker() 再到全局,這條查找路徑就是所謂的「作用域鏈」。

新問題隨之而來:既然 tick() 也被藏在作用域裡,外部該怎麼調用它?有兩條路:一是把方法作為返回值拋出去,二是掛到外層作用域的變量上。

var getN;
function ticker(config) {
  var n = config.nStart;
  getN = function () {
    return n;
  };
  return function () {
    n += config.step;
  };
}

var tick = ticker({ nStart: 100, step: 2 });
tick();
console.log(getN()); // -> 102

這時 n 就活在閉包之中:外部拿不到它,卻可以通過兩個受控入口去觀察或改變它。

兩段代碼的關鍵差別在於生命週期。第一段裡,ticker() 執行完畢後 n 和 tick() 就被銷毀,下次調用再重建;第二段裡,ticker() 結束後 n 並不會被回收,因為 tick() 與 getN() 還可能讀寫它,引擎必須設法維持。我對閉包的理解就是這樣一套機制:保證那些「作用域在函數內、函數執行完後仍需存活、可能被間接訪問」的變量不被回收。

new 運算符與構造函數

但如果需要 ticker1、ticker2 兩個同功能實例呢?總不能將 ticker() 抄兩遍。用 new 調用函數時,引擎會創建新對象並以它為 this 執行該函數。下面兩種寫法本質相同:

function myClass() {}
var t1 = new myClass();
var t2 = {};
t2.func = myClass;
t2.func();
t2.func = undefined;

於是可以改寫成:

function TICKER(config) {
  var n = config.nStart;
  this.getN = function () {
    return n;
  };
  this.tick = function () {
    n += config.step;
  };
}

var ticker1 = new TICKER({ nStart: 100, step: 2 });
ticker1.tick();
console.log(ticker1.getN()); // -> 102

var ticker2 = new TICKER({ nStart: 20, step: 3 });
ticker2.tick();
ticker2.tick();
console.log(ticker2.getN()); // -> 26

慣例上構造函數首字母大寫。注意 TICKER() 仍然是函數(嚴格說是函數對象),閉包照舊生效,外部依然讀不到 ticker1.n。

原型與繼承:讓方法只存在一份

上面這版還有個隱患:ticker1.tick 和 ticker2.tick 是兩個互相獨立的函數。每 new 一次,瀏覽器就要為新對象開闢空間,保存 tick 函數本身及其引用的變量。這顯然是我們不想要的——理想狀態是兩個實例共享同一個函數對象。

這就需要原型。JavaScript 中除 Object 外的對象都帶有 prototype 屬性,指向另一個對象,而後者又有自己的原型,如此串成原型鏈,最終指向 Object。調用某方法時若當前對象沒有,就沿原型鏈逐級上溯。函數也是對象,函數被定義時會生成一個原型對象,其 constructor 反向指回該函數;由構造函數 new 出的實例,原型即指向構造函數的 prototype。

直覺的做法是把方法搬到原型上:

function TICKER(config) {
  var n = config.nStart;
}
TICKER.prototype.getN = function () {
  // attention: 無效實現
  return n;
};
TICKER.prototype.tick = function () {
  // attention: 無效實現
  n += config.step;
};

但這是行不通的。原型上的方法訪問不到閉包變量 n,TICKER() 執行結束後 n 就被回收了。正確的分工是:構造函數裡保留少量「貼近數據」的簡潔方法作為閉包入口,複雜的公有邏輯放到原型上,通過調用這些小方法來操作數據。

本例中 tick() 已經足夠簡潔,把它留在構造函數裡即可;再來實現一個稍複雜的 tickTimes(),允許調用方指定遞增次數:

function TICKER(config) {
  var n = config.nStart;
  this.getN = function () {
    return n;
  };
  this.tick = function () {
    n += config.step;
  };
}

TICKER.prototype.tickTimes = function (n) {
  while (n > 0) {
    this.tick();
    n--;
  }
};

var ticker1 = new TICKER({ nStart: 100, step: 2 });
ticker1.tick();
console.log(ticker1.getN()); // -> 102

var ticker2 = new TICKER({ nStart: 20, step: 3 });
ticker2.tickTimes(2);
console.log(ticker2.getN()); // -> 26

這樣的 TICKER 就比較理想了:n 被封裝,外部無法直接改寫;複雜方法 tickTimes() 定義在原型上只存一份,內部再通過實例上的小方法操作數據。

由此可以歸納出一條實踐建議:把對數據的操作拆分為盡可能小的單元函數,在構造函數中定義為依賴實例的(很多地方稱之為「私有」);把複雜的業務邏輯掛在原型上作為「公有」方法。

最後談談 JavaScript 的「繼承」

其實當我們往原型上添加函數時,就已經在用繼承了。JavaScript 的繼承比 C++ 的更……簡單,或者說更簡陋。C++ 裡我們會定義 animal 類,再定義 bird 繼承 animal;但這裡想說的是另一種情況:C++ 中定義 animal 類然後實例化一個 myAnimal 對象,這在 C++ 裡叫實例化,在 JavaScript 中卻被當作繼承來看待。

JavaScript 並不支持類。引擎只關心當前有哪些對象,不會額外追究它們屬於哪個 class、應該具備什麼結構。在我們的例子裡,TICKER() 是個函數對象,可以被賦值(TICKER = 1)也可以被刪除,但正因為有 ticker1、ticker2 是 new 它而來的,它就承擔了構造函數的角色,而 TICKER.prototype 則承擔了「類」的角色。

以上就是我在 JavaScript 模塊化方面的理解。如果你也是初學者,希望這條從閉包到原型的推演路徑能省下你一些摸索的時間。

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