本文整理自 jQuery Summit 上一場關於大型 JavaScript 應用架構的議程(原始 PPT 可於 SlideShare 搜尋 jqquerysummit-largescale-javascript-application-architecture)。原作者的表達有些來回繞,這裡做了刪減與重組,英文能力好的話直接讀原版 PPT 會更原汁原味。
全文主線:
1. 什麼算「大型 JavaScript 程式」
2. 回顧現有架構
3. 長遠考慮
4. 頭腦風暴
5. 建議的架構(設計模式 / 如何落地)
6. Pub/Sub 的延伸:自動註冊事件
7. Q & A
先定義「大」。有人說超過十萬行才算大型,有人說超過 1MB 才算,但這兩個標準都不成立——瑣碎的 JS 很容易就堆到十萬行,卻一點也不「大」。
作者給的定義是:大型 JavaScript 程式,指的是那些至關重要、投入了大量優秀開發者心力、處理並呈現重量級資料給瀏覽器的程式。重點在於「重要性」與「資料量」,而不是程式碼行數。
很多資深開發者會說:「現有的創意和設計模式在我上一個中型專案上跑得很好,放到大一點的專案應該也没問題吧?」某種程度上沒錯,但別忘了——既然是大型程式,通常伴隨而來的是更龐大、更需要拆解的關注點。
多數現有 JS 架構大致長這樣(注意這裡講的是前端 JS 架構,不是 ASP.NET MVC 那種後端架構):
custom widgets
models
views
controllers
templates
libraries/toolkits
an application core.
你可能還會把程式封裝成多個 modules,或採用其他設計模式,這很好。但如果這些結構就完整代表了你的架構,那潛在問題不少。作者提出四個捫心自問:
1. 你的架構裡,有多少東西可以立刻拿出來重用?有沒有一些模組不依賴其他程式碼、完全自包含?如果隨便從程式庫挑一個 module 丟到新頁面,能不能不改一行就動?你可能覺得「原理通就行」,但試想:某天有人說「這個專案的聊天模組不錯,我們搬到另一個專案吧」,你能直接搬過去嗎?
2. 系統裡有多少模組需要依賴其他模組?這裡不是說模組絕對不能有任何依賴——某個細粒度功能從 base 功能擴展出來,這種依賴是合理的。作者關心的是不同功能模組之間的依賴。理論上,這些彼此不該有太多牽連。
3. 如果程式的某一部分出錯了,其他部分還能正常運作嗎?看看 Gmail 就知道了:聊天模組是動態載入的,初始頁面根本不載它;而且就算載入後出錯了,頁面其他部分照樣能用。
4. 你的各個模組容易測試嗎?你的模組可能會被用在數百萬使用者的站點上,甚至多個站點共用,所以它必須經得起測試。不論在架構內部還是外部,都該能簡單地測,而且大部分斷言在不同環境下都能通過。
設計大型程式時最重要的是前瞻性。不能只想一個月、一年後怎樣,而要想更長遠的可能變化。開發者常把 DOM 操作程式碼跟程式邏輯綁得太緊,即使已經把邏輯封裝進不同模組了,長期下來仍然會痛。
有同事說過「精確的架構可能不適合未來的情境」,這句話有時是對的——但當你真的需要改造時,要付出的成本(時間、人力、金錢)會相當可觀。舉例說,你可能因為效能、安全或設計理由,需要在 Dojo、jQuery、Zepto、YUI 之間替換底層類 庫。這時候如果大部分模組都有依賴,問題就來了。
小型站點這樣做沒什麼,但大型站點確實需要更靈活的機制,不必為模組之間的糾葛買單。既省錢又省時間。
所以總結一句:你現在能確定自己可以不重寫整個程式,就替換掉某些類 庫嗎?如果不能,下面的內容就很適合你。
幾位業界人士的關鍵觀點:
JavaScriptMVC 作者 Justin Meyer:構建大型程式最大的秘密,就是從來不構建大型程式,而是把它分解成各個小模組,讓每個小模組可測試、可縮放,然後整合起來。
《High-performance JavaScript websites》作者 Nicholas Zakas:「關鍵在於一開始就承認你並不知道它會長成什麼樣子。當你接受自己並非無所不知,你就會開始防禦性地設計系統。你找出那些可能變動的關鍵區域——只要花一點心思,這通常不難辨認。舉例來說,任何與外部系統通訊的部分幾乎一定會改,所以你得把它抽象化。」一句話總結:一切皆可變,所以要抽象。
《jQuery Fundamentals》作者 Rebecca Murphey:模組之間的耦合越緊密,重用性就越低,改動起來也越困難。
我們需要一個鬆耦合的架構:模組之間沒有直接依賴,各模組只跟程式溝通,中間層負責接收與回應訊息。
想像一個用 JavaScript 寫的在線麵包店,某個模組發出一則訊息:「有 42 個圓麵包需要派件」。不同層級負責處理模組拋出的訊息,做到:
模組不直接存取程式核心
模組不直接呼叫或影響其他模組
這樣就能避免一個模組出錯拖垮全部。
另一個被忽略的議題是內部安全。多數人不認為這是問題,心裡想著「程式是我自己寫的,我知道哪些是公開的、哪些是私有的」。但你有辦法定義哪個模組才有權限存取程式核心嗎?舉例說,聊天模組不該能呼叫 admin 模組,也不該能呼叫有資料庫寫入權限的模組——這中間的界線一旦模糊,就很容易被拿來做 XSS 攻擊。每個模組不該能做所有事,但當前多數架構的 JS 程式碼都有這個毛病。提供一個中間層來控管授權,模組最多只能做到它被授權的那部分。
重點來了。這裡提出的架構用了三個我們都熟悉 的設計模式:module、facade 和 mediator。
與傳統做法不同的是,為了讓模組彼此解耦,模組只負責發布事件;mediator 負責向模組訂閱訊息並控制回應流程;facade 則負責限制各模組的權限。
大家多少都寫過模組化的程式碼。模組是完整健壯架構的一部分,每個模組都是為單一目的而建立。回到 Gmail:聊天功能看起來是一個獨立部分,其實它由許多子模組構成,例如裡面的表情模組就是獨立子模組,同時也被用在寄信視窗上。另外,模組應該能被動態載入、移除與替換。
JavaScript 裡實作模組的方式,最常見的是 Module 模式與物件字面量。
Module 模式用閉包把私有變數、方法與狀態包起來,外部無法直接存取,只暴露一個 API 出去。
它跟自執行函數表達式很相似,唯一差別是 Module 模式回傳的是物件,而單純的自執行函數回傳的是 function。
JavaScript 沒有其他語言那種存取修飾符,沒辦法逐個欄位宣告 private/public,那怎麼做到?答案就是 return 一個物件,裡面放公開方法,這些方法有權存取內部狀態。
var basketModule = (function() { var basket = []; //private return { //exposed to public addItem: function(values) { basket.push(values); }, getItemCount: function() { return basket.length; }, getTotal: function(){ var q = this.getItemCount(),p=0; while(q--){ p+= basket[q].price; } return p; } } }());
return 的物件直接賦給 basketModule,所以可以這樣用:
//basketModule is an object with properties which can also be methods basketModule.addItem({item:'bread',price:0.5}); basketModule.addItem({item:'butter',price:0.3}); console.log(basketModule.getItemCount()); console.log(basketModule.getTotal()); //however, the following will not work: console.log(basketModule.basket);// (undefined as not inside the returned object) console.log(basket); //(only exists within the scope of the closure)
Dojo 的做法:用 dojo.declare 提供 class 風格的宣告,搭配 dojo.setObject 掛進命名空間:
//traditional way var store = window.store || {}; store.basket = store.basket || {}; //using dojo.setObject dojo.setObject("store.basket.object", (function() { var basket = []; function privateMethod() { console.log(basket); } return { publicMethod: function(){ privateMethod(); } }; }()));
再搭配 dojo.provide 一起用,效果更完整。
YUI 的做法:
YAHOO.store.basket = function () { //"private" variables: var myPrivateVar = "I can be accessed only within YAHOO.store.basket ."; //"private" method: var myPrivateMethod = function () { YAHOO.log("I can be accessed only from within YAHOO.store.basket"); } return { myPublicProperty: "I'm a public property.", myPublicMethod: function () { YAHOO.log("I'm a public method."); //Within basket, I can access "private" vars and methods: YAHOO.log(myPrivateVar); YAHOO.log(myPrivateMethod()); //The native scope of myPublicMethod is store so we can //access public members using "this": YAHOO.log(this.myPublicProperty); } }; } ();
jQuery 的做法:這裡有個不太一樣的例子——宣告一個 library 函數,建立時會在 document.ready 自動執行 init:
function library(module) { $(function() { if (module.init) { module.init(); } }); return module; } var myLibrary = library(function() { return { init: function() { /*implementation*/ } }; }());
物件字面量用大括號宣告,使用時不需要 new。如果你不太在意模組內部哪些是公開、哪些是私有,這種寫法很夠用。注意它和 JSON 的格式差異:物件字面量是 var item={name: "tom", value:123},JSON 則是 var item={"name":"tom", "value":123},鍵必須加引號。
var myModule = { myProperty: 'someValue', //object literals can contain properties and methods. //here, another object is defined for configuration //purposes: myConfig: { useCaching: true, language: 'en' }, //a very basic method myMethod: function () { console.log('I can haz functionality?'); }, //output a value based on current configuration myMethod2: function () { console.log('Caching is:' + (this.myConfig.useCaching) ? 'enabled' : 'disabled'); }, //override the current configuration myMethod3: function (newConfig) { if (typeof newConfig == 'object') { this.myConfig = newConfig; console.log(this.myConfig.language); } } }; myModule.myMethod(); //I can haz functionality myModule.myMethod2(); //outputs enabled myModule.myMethod3({ language: 'fr', useCaching: false }); //fr
CommonJS 有兩個關鍵參數:exports 代表要輸出的內容,require 代表要載入的依賴。
/* Example of achieving compatibility with AMD and standard CommonJS by putting boilerplate around the standard CommonJS module format: */ (function(define){ define(function(require,exports){ // module contents var dep1 = require("dep1"); exports.someExportedFunction = function(){...}; //... }); })(typeof define=="function"?define:function(factory){factory(require,exports)});
CommonJS 的模組載入實作很多,其中 RequireJS 是比較受歡迎的一個。舉個例子,要把圖片轉成 ASCII 碼,直覺寫法是:
var encodeToASCII = require("encoder").encodeToASCII; exports.encodeSomeSource = function(){ //其它操作以後,然後調用encodeToASCII }
但這段其實不會動,因為 encodeToASCII 並沒有掛在 window 上。必須包在 define 裡才成立:
define(function(require, exports, module) { var encodeToASCII = require("encoder").encodeToASCII; exports.encodeSomeSource = function(){ //process then call encodeToASCII } });
Facade 在這個架構裡佔有重要角色,很多 JavaScript 類 庫或框架都有它的影子。最大的作用是提供一層高階 API,把具體實作藏起來。也就是說,我們只暴露介面,內部實作由我們自己決定——這也意味著內部程式碼可以隨時替換更新。今天用 jQuery 實作,明天想換成 YUI,改動範圍就小得多。
var module = (function () { var _private = { i: 5, get: function () { console.log('current value:' + this.i); }, set: function (val) { this.i = val; }, run: function () { console.log('running'); }, jump: function () { console.log('jumping'); } }; return { facade: function (args) { _private.set(args.val); _private.get(); if (args.run) { _private.run(); } } } } ()); module.facade({run:true, val:10}); //outputs current value: 10, running
Facade 和後面要講的 Mediator 有個重要區別:Facade 只提供既有功能,Mediator 可以協調出新的行為。
先舉個例子。機場的航管系統,也就是塔台,擁有絕對權力,能決定任何一架飛機的起降時間與位置;而飛機彼此之間不允許通訊。塔台就是機場的核心,Mediator 就相當於這個塔台。
當程式裡有多個模組,而你又不想讓它們互相依賴時,Mediator 模式能達到集中控制的目的。它封裝了許多不相干的模組,讓它們透過 Mediator 產生聯繫,同時保持鬆耦合——模組之間必須經過 Mediator 才能溝通。
Mediator 的優點是解耦。如果你熟悉觀察者模式,理解下面這張圖會容易很多:

想像各模組是發布者,而 Mediator 同時是發布者也是訂閱者:
Module 1 向 Mediator 廣播一個事件,表示需要做某事
Mediator 收到訊息後,啟動處理該事件所需的 Module 2,Module 2 處理完回傳結果給 Mediator
與此同時,Mediator 也啟動了 Module 3,Module 2 的結果回來時自動記錄日誌到 Module 3
可以看到,模組之間並沒有直接通訊。另外 Mediator 也能監控各模組狀態:若 Module 3 出錯,Mediator 可以暫時只把訊息導向其他模組,重啟 Module 3 後再恢復。
歸納一下 Mediator 的優點:鬆耦合的模組由統一的 Mediator 控管,模組只需發布與監聽事件,彼此不必直接聯繫;一次訊息的處理可以調動多個模組;未來要加入新模組到既有流程也方便。
代價是:由於模組之間不能直接通訊,效能上會有某種程度的下降。作者認為這是值得的交換。
一個簡短的 Demo:
var mediator = (function(){ var subscribe = function(channel, fn){ if (!mediator.channels[channel]) mediator.channels[channel] = []; mediator.channels[channel].push({ context: this, callback: fn }); return this; }, publish = function(channel){ if (!mediator.channels[channel]) return false; var args = Array.prototype.slice.call(arguments, 1); for (var i = 0, l = mediator.channels[channel].length; i < l; i++) { var subscription = mediator.channels[channel][i]; subscription.callback.apply(subscription.context, args); } return this; }; return { channels: {}, publish: publish, subscribe: subscribe, installTo: function(obj){ obj.subscribe = subscribe; obj.publish = publish; } }; }());
兩個模組分別呼叫:
//Pub/sub on a centralized mediator mediator.name = "tim"; mediator.subscribe('nameChange', function(arg){ console.log(this.name); this.name = arg; console.log(this.name); }); mediator.publish('nameChange', 'david'); //tim, david //Pub/sub via third party mediator var obj = { name: 'sam' }; mediator.installTo(obj); obj.subscribe('nameChange', function(arg){ console.log(this.name); this.name = arg; console.log(this.name); }); obj.publish('nameChange', 'john'); //sam, john
facade 作為應用程式核心的抽象層,站在 mediator 與模組之間負責溝通。各模組只能透過這個 facade 跟核心互動。
作為抽象層,它的職責是隨時為模組提供一致的介面,角色有點像 sandbox controller。所有模組元件都透過它與 mediator 溝通,所以 facade 必須可靠、可信賴。
除此之外,facade 還肩負另一個角色:安全控制——決定程式的哪個部分可以被哪個模組存取。模組只能呼叫自己的方法,不能碰任何未授權的內容。舉例說,某個模組廣播 dataValidationCompletedWriteToDB,這裡的安全檢查就必須確認該模組真的擁有資料庫寫入權限。
總之,mediator 只有在 facade 授權檢查通過後,才會進行訊息處理。
Mediator 扮演應用程式核心的角色,最核心的工作是管理模組的生命週期。當它攔到任何進來的訊息時,必須判斷程式該如何處理,也就是決定啟動或停止哪些模組。
一個模組啟動時,是否要自動執行,應該由模組自己判斷(例如是否要等 DOM ready),而不該由核心替你決定。
那模組什麼時候該停止?當程式偵測到某模組失敗或出錯,核心需要決定暫停繼續執行該模組的方法,好讓這個元件可以重啟,目的是維持使用者體驗。
此外,核心應該能動態加入或移除模組,不影響其他功能。常見場景是某模組在頁面載入初期不可用,使用者操作後才動態載入並執行——就像 Gmail 的聊天功能。從效能優化角度看,這個設計很好理解。
異常錯誤處理同樣由核心負責。各模組廣播訊息時,也把任何錯誤一併廣播給核心,讓它能依情況停止或重啟模組。這是鬆耦合架構很關鍵的一環:我們不需要手動改動任何模組程式碼,光靠 mediator 的發布/訂閱機制就能做到。
各模組包含程式裡形形色色的功能,當它們有需要處理的事情時,就發布訊息通知程式——這是它們的主要職責。模組可以依賴一些 DOM 操作工具方法,但不應該依賴系統的其他模組。一個模組不該去關心:
1. 哪個物件或模組訂閱了它發布的訊息
2. 這些訂閱者是前端物件還是伺服器端物件
3. 有多少物件訂閱了它的訊息

Facade 抽象了應用程式核心,避免模組之間直接通訊。它向各模組訂閱訊息,也負責授權檢查,確保每個模組擁有自己的權限邊界。

Mediator(應用程式核心)扮演發布/訂閱管理器的角色,負責模組管理與啟動/停止,可以動態載入並重啟出錯的模組。

這樣的結果是:模組之間沒有依賴,因為鬆耦合而容易測試與維護,可以輕易搬到其他專案重用,也能在不影響程式的情況下動態加入或移除。
自動註冊事件需要遵守命名慣例。例如某模組發布了一個名為 messageUpdate 的事件,那麼所有帶有 messageUpdate 方法的模組都會被自動執行。這有好處也有風險,實作細節可以參考作者另一篇文章。
Q1:可以不用 facade 或類似的 sandbox 模式嗎?
雖然架構大綱裡提到 facade 可以負責授權檢查,但這件事完全可以交給 mediator 做。輕量版架構要做的事其實幾乎一樣,重點是解耦,確保模組與程式核心的溝通管道暢通即可。
Q2:你說模組之間不能有依賴,難道也不能依賴 jQuery 這種第三方類 庫?
這是兩面性的問題。前面提到模組可能有子模組或基礎模組,比如基本的 DOM 操作工具類,在這個層面上當然可以用第三方類 庫。但請確保——我們隨時能把它替換掉。
Q3:想開始用這個架構,有程式碼範本嗎?
作者當時計畫整理一份範本。在那之前,可以先參考 Andrew Burgees 的〈Writing Modular JavaScript〉。
Q4:模組可以直接跟程式核心溝通嗎?
技術上沒有理由不行,但對大多數應用體驗來說,最好不要。既然你選了這個架構,就該遵守它定義的規則。
感謝 Nicholas Zakas 的原始分享把這些想法整理在一起,感謝 Andree Hansson 的技術審閱,也感謝 Rebecca Murphey、Justin Meyer、John Hann、Peter Michaux、Paul Irish 與 Alex Sexton,他們都提供了大量相關資料。