DIV CSS 佈局教程網

JavaScript Module 模式深入解析:從閉包到高擴展性的模組設計
編輯:關於JavaScript     

在 ES Module 與打包工具普及之前,Module 模式是組織大型 JavaScript 應用的主力手法。它用一個匿名函式閉包,同時解決了「私有狀態」與「避免全域污染」兩個難題,還能透過幾種變化型態支援擴展與多檔拆分。理解它,等於理解了模組化思想的起點。

基礎一:匿名函式閉包

匿名函式閉包是 JavaScript 最強的特徵,整個 Module 模式都建立在它之上。建立一個匿名函式並立即執行,函式內的所有程式碼都在這個閉包中運行,決定了它們的私有性與狀態。

(function () {
  // ... 這裡的所有變數與函式都只在這個 scope 內
  // 仍可存取所有全域變數
}());

注意最外層那對括號。這是因為在 JavaScript 中,以 function 開頭的語句會被視為函式宣告;加上外層括號後,它才變成函式運算式,可以立即呼叫。

基礎二:全域導入

JavaScript 有個「隱藏全域變數」的特性:使用一個變數時,編譯器會往上一層層尋找用 var 宣告它的語句;若一路找不到,它就會變成全域。在賦值時這樣做,等於直接創造一個全域變數。

這代表在匿名閉包裡不小心建立全域變數非常容易,而全域變數到處飄移會讓程式難以維護——因為其他地方的開發者無從得知它從哪裡來。幸運的是,匿名函式提供了另一個選擇:透過參數把全域變數導入,既快速又整潔。

(function ($, YAHOO) {
  // 現在這段程式碼中可以直接使用 jQuery(以 $ 表示)與 YAHOO
}(jQuery, YAHOO));

基礎三:模組導出

有時你不想用全域,但仍需要對外暴露某些東西。做法很簡單:讓匿名函式回傳一個物件。

var MODULE = (function () {
  var my = {},
      privateVariable = 1;

  function privateMethod() {
    // ...
  }

  my.moduleProperty = 1;
  my.moduleMethod = function () {
    // ...
  };

  return my;
}());

這裡宣告了一個全域模組 MODULE,對外公開兩個成員:MODULE.moduleMethod 方法與 MODULE.moduleProperty 變數。而 privateVariable 與 privateMethod 因為沒有被掛到 my 上,外部完全無法存取——它們靠閉包維持私有狀態。這就是「暴露介面、隱藏實作」的經典實踐。

高級一:擴展(Extension)

基本模式有個明顯限制:整個模組必須寫在同一個檔案裡。而做過大型專案的人都知道拆分檔案的重要性。解法是:先導入模組、加上新屬性、再導出。

var MODULE = (function (my) {
  my.anotherMethod = function () {
    // 新增的方法...
  };

  return my;
}(MODULE));

雖然不是必要,但為了一致性仍再次使用 var。執行後,MODULE 就多了一個 anotherMethod。這個擴展檔同樣保有自己的私有狀態與導入的全域變數。

高級二:鬆擴展(Loose Augmentation)

上面的例子要求模組必須先存在才能擴展,這其實不是必要的。異步載入腳本是提升 JavaScript 應用效能的最佳手段之一,而鬆擴展讓我們能把模組拆成多檔、以任意順序載入。每個檔案的結構大致如下:

var MODULE = (function (my) {
  // 增加能力...

  return my;
}(MODULE || {}));

關鍵是 MODULE || {}:匯入的模組若不存在,就先建一個空物件。這裡 var 是必須的。這種寫法讓你可以用 LABjs 這類工具並行載入各個模組檔,不必擔心順序。

高級三:緊擴展(Tight Augmentation)

鬆擴展很棒,但也帶來限制:你無法安全地覆寫模組的屬性,初始化時也不能使用其他檔案中的模組屬性(初始化之後的執行期使用則沒問題)。緊擴展需要一定的載入順序,但換來了覆寫能力:

var MODULE = (function (my) {
  var old_moduleMethod = my.moduleMethod;

  my.moduleMethod = function () {
    // 方法覆寫,仍可透過 old_moduleMethod 存取原始版本
  };

  return my;
}(MODULE));

這裡我們覆寫了 MODULE.moduleMethod,並保留了對原方法的參照。這個技巧在你想「包裝」而非「取代」既有行為時非常有用——例如加上日誌、參數快取或錯誤處理,再呼叫原方法。

高級四:複製與繼承

var MODULE_TWO = (function (old) {
  var my = {},
      key;

  for (key in old) {
    if (old.hasOwnProperty(key)) {
      my[key] = old[key];
    }
  }

  var super_moduleMethod = old.moduleMethod;
  my.moduleMethod = function () {
    // 在複製品上覆寫方法,透過 super_moduleMethod 存取原始版本
  };

  return my;
}(MODULE));

這種模式可能是最不靈活的一種。雖然支援某種優雅的「合併」,代價是犧牲了靈巧性:在我們寫的程式碼中,那些型別是物件或函式的屬性並不會被複製,只會變成兩個參照指向同一份東西——改動一個,另一個也跟著變。對於物件,可以寫遞迴的深拷貝來解決;但對於函式,除了 eval 之外沒有真正可行的辦法。

高級五:跨檔案的私有狀態

把模組拆成多檔有個重大限制:每個檔案維持自己的私有狀態,且無法取得其他檔案的私有狀態。這個問題可以解決:

var MODULE = (function (my) {
  var _private = my._private = my._private || {},
      _seal = my._seal = my._seal || function () {
        delete my._private;
        delete my._seal;
        delete my._unseal;
      },
      _unseal = my._unseal = my._unseal || function () {
        my._private = _private;
        my._seal = _seal;
        my._unseal = _unseal;
      };

  // 對 _private、_seal、_unseal 的永久存取權

  return my;
}(MODULE || {}));

每個檔案都可以在 _private 上設定屬性,其他檔案能立即取用。當模組全部載入完畢後,程式呼叫 MODULE._seal(),把 _private 從公開介面上刪除,外部再也無法直接接觸內部狀態。之後若模組要再次擴展,各檔案在載入新檔前呼叫 _unseal(),執行完再呼叫 _seal() 封回。

這是一個有點聰明但也略顯 hacky 的手法——用「暫時公開、用完密封」的方式模擬跨檔的私有性。它展現了閉包搭配參照操作能玩到什麼程度。

高級六:子模組(Sub-modules)

最後一個模式其實最簡單:

MODULE.sub = (function () {
  var my = {};
  // ...

  return my;
}());

子模組享有一般模組的所有優點,包括擴展與私有狀態。而且它可以像這樣「不存在就建立」:

var UTIL = (function (parent, $) {
  var my = parent.ajax = parent.ajax || {};

  my.get = function (url, params, callback) {
    return $.getJSON(url, params, callback);
  };

  // etc...

  return parent;
}(UTIL || {}, jQuery));

這個寫法讓複雜、多層次的程式碼可以並行載入,包含子模組在內的所有部分。

總結

多數高級模式都能互相組合以創造更有用的新結構。若要為複雜應用提出一個設計方案,我會選擇結合鬆擴展、私有狀態與子模組:以鬆擴展支援並行載入與任意順序,以私有狀態保護內部實作,以子模組組織功能層次。

效能方面,Module 模式也有好處:它可以顯著減少全域變數數量,而全域變數的存取在 JavaScript 中比區域變數慢;鬆擴展讓並行載入成為可能,直接改善首屏速度。初始化時間或許比其他方式長一些,但這點成本是值得的。只要全域都被正確導入,執行期就不會有問題,而子模組中因為變數的參照鏈變短,速度甚至可能更快。

寫在之後:Module 模式的歷史位置

這套模式在 2007 年前後由 YUI 團隊推廣開來,是 CommonJS 與 AMD(Asynchronous Module Definition)規格的設計靈感來源,也直接影響了 Node.js 的 require() 與 RequireJS 的 define()。

今天的標準答案已經是 ES2015 的 native module:

// utils.js
const _private = "只有模組內可見";
export function greet(name) {
  return `Hello, ${name}. ${_private}`;
}
export default { greet };

// main.js
import utils, { greet } from "./utils.js";

它原生支援私有範圍、靜態可分析(打包工具能在編譯期決定依賴圖,做 tree-shaking)、非同步載入(import())與循環依賴處理,幾乎涵蓋了 Module 模式所有想解決的問題,而且不需要任何 hack。

那為什麼還要學 Module 模式?三個理由:一是維護舊程式碼時必然遇到;二是它教會你閉包、作用域鏈與副作用管理等真正重要的觀念;三是當你在設定 bundler、除錯 Scope、或設計自己的模組邊界時,這些思考方式仍然管用。工具會換,原理不會。

本文整理自 Ben Cherry 的文章,是理解 JavaScript 模組化歷程的一份好材料。少年們,努力吧,寫出更好的、更模組化的 JavaScript。

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