模塊化的本質是把 JS 拆分成多個職責單一的單元,便於開發與維護;而模塊加載系統要解決的,是如何按依賴關係把它們正確、高效地取回來並執行。本文以 sea.js 為例,梳理一次完整的加載流程。
function loadJs(url, callback){
var node = document.createElement("script");
node[window.addEventListener ? "onload" : "onreadystatechange"] = function(){
if(window.addEventListener || /loaded|complete/i.test(node.readyState)){
callback();
node.onreadystatechange = null;
}
}
node.onerror = function(){};
node.src = url;
var head = document.getElementsByTagName("head")[0];
head.insertBefore(node, head.firstChild);
// 插入到 head 的第一個節點前,防止 IE6 下 head 尚未閉合時 appendChild 報錯
}
頁面 chaojidan.jsp 在 head 中引入 sea.js 與 index.js。index.js 內容如下:
seajs.use(['./a','jquery'], function(a, $){
var num = a.a;
$('#J_A').text(num);
});
a.js:
define(function(require, exports, module){
var b = require('./b');
var a = function(){
return 1 + parseInt(b.b());
}
exports.a = a;
});
b.js 依賴 c.js,c.js 直接返回常量 3。由此形成 a → b → c 的依賴鏈。
seajs.use = function(ids, callback) {
globalModule._use(ids, callback);
}
globalModule 是 sea.js 初始化時創建的 Module 實例:var globalModule = new Module(util.pageUri, STATUS.COMPILED)。此時 ids 為 ['./a','jquery'],callback 為最終的業務回調(下文記為 callback1)。
Module.prototype._use = function(ids, callback) {
var uris = resolve(ids, this.uri); // 解析出模塊的絕對地址
this._load(uris, function() { // 記為 callback2
var args = util.map(uris, function(uri) {
return uri ? cachedModules[uri]._compile() : null;
});
if (callback) { callback.apply(null, args) }
});
}
resolve 負責把相對路徑解析為絕對 URL,最終 uris 變成 ['https://localhost/test/SEAJS/a.js', 'https://localhost/test/SEAJS/lib/jquery/1.7.2/jquery-debug.js']。
_load 首先篩出尚未 ready 的模塊;若全部就緒,直接執行 callback2。同時它還要處理循環依賴,並為未加載的 js 觸發下載:
Module.prototype._load = function(uris, callback2) {
var unLoadedUris = util.filter(uris, function(uri) {
// uri 存在,且在緩存中不存在或其 status 小於 READY(4)
return uri && (!cachedModules[uri] ||
cachedModules[uri].status < STATUS.READY);
});
var length = unLoadedUris.length;
if (length === 0) { callback2(); return }
var remain = length;
for (var i = 0; i < length; i++) {
(function(uri) {
var module = cachedModules[uri] ||
(cachedModules[uri] = new Module(uri, STATUS.FETCHING));
// 已下載完成則直接 onFetched,否則 fetch 後再回調
module.status >= STATUS.FETCHED ? onFetched() : fetch(uri, onFetched);
function onFetched() {
module = cachedModules[uri];
if (module.status >= STATUS.SAVED) {
var deps = getPureDependencies(module);
if (deps.length) {
// 遞歸 _load 直到依賴全部就緒
Module.prototype._load(deps, function() { cb(module) });
} else {
cb(module);
}
} else {
cb(); // 404 或不符合模塊化規範,status 會停在 FETCHING/FETCHED
}
}
})(unLoadedUris[i]);
}
function cb(module) {
module && (module.status = STATUS.READY);
--remain === 0 && callback2(); // 全部完成才執行 callback2
}
}
fetch 透過三張表避免重複請求:fetchedList 記錄已完成的 URI,fetchingList 記錄下載中的 URI,callbackList 收集同一 URI 的多個回調。下載完成後統一遍歷執行 callbackList,再清空記錄。
function fetch(uri, onFetched) {
var requestUri = util.parseMap(uri);
if (fetchedList[requestUri]) { // 已獲取過
cachedModules[uri] = cachedModules[requestUri];
onFetched();
return;
}
if (fetchingList[requestUri]) { // 正在獲取中,掛入回調隊列
callbackList[requestUri].push(onFetched);
return;
}
fetchingList[requestUri] = true;
callbackList[requestUri] = [onFetched];
Module._fetch(requestUri, function() {
fetchedList[requestUri] = true;
var module = cachedModules[uri];
if (module.status === STATUS.FETCHING) {
module.status = STATUS.FETCHED;
}
if (fetchingList[requestUri]) { delete fetchingList[requestUri] }
if (callbackList[requestUri]) {
util.forEach(callbackList[requestUri], function(fn) { fn() });
delete callbackList[requestUri];
}
}, config.charset);
}
腳本下載完成後執行的是 define。若 deps 不是數組而 factory 是函數,就透過 factory.toString() 做正則匹配,從函數體中抽出 require 的調用並形成依賴數組。之後把 id、deps、factory 打包成 meta 保存起來。
Module._define = function(id, deps, factory) {
if (!util.isArray(deps) && util.isFunction(factory)) {
deps = util.parseDependencies(factory.toString());
}
var meta = { id: id, dependencies: deps, factory: factory };
if (document.attachEvent) {
var script = util.getCurrentScript();
if (script) {
derivedUri = util.unParseMap(util.getScriptAbsoluteSrc(script));
}
if (!derivedUri) {
util.log('Failed to derive URI from interactive script for:', factory.toString(), 'warn');
}
}
// ......
}
這裡有個值得記下的瀏覽器差異:IE6-9 可以透過 document.currentScript 之類的機制拿到當前執行腳本的路徑,標準瀏覽器當時並不具備這個能力,所以只能先把元信息暫存到 anonymousModuleMeta,等 onload 觸發時再關聯到具體模塊。
當所有模塊都進入 READY 狀態,callback2 被執行,對每個 uri 調用 _compile()。_compile 主要做四件事:處理異常狀態、把狀態置為 COMPILING、注入 require/exports/module 三個成員、執行 factory。
Module.prototype._compile = function() {
var module = this;
if (module.status === STATUS.COMPILED) { return module.exports }
if (module.status < STATUS.SAVED && !hasModifiers(module)) { return null }
module.status = STATUS.COMPILING;
function require(id) {
var uri = resolve(id, module.uri);
var child = cachedModules[uri];
if (!child) { return null }
// 子模塊正在編譯中,直接返回其 exports,避免循環依賴導致無限遞歸
if (child.status === STATUS.COMPILING) { return child.exports }
child.parent = module;
return child._compile();
}
require.async = function(ids, callback) { module._use(ids, callback) };
require.resolve = function(id) { return resolve(id, module.uri) };
require.cache = cachedModules;
module.require = require;
module.exports = {};
var factory = module.factory;
if (util.isFunction(factory)) {
compileStack.push(module);
runInModuleContext(factory, module);
compileStack.pop();
} else if (factory !== undefined) {
module.exports = factory;
}
module.status = STATUS.COMPILED;
execModifiers(module);
return module.exports;
}
runInModuleContext 負責以模塊上下文呼叫 factory,並支援 return 對象形式的接口暴露:
function runInModuleContext(fn, module) {
var ret = fn(module.require, module.exports, module);
if (ret !== undefined) {
module.exports = ret;
}
}
編譯 a 時,執行到 var b = require('./b') 會遞歸觸發 b 的 _compile,b 又觸發 c。因此實際執行順序是 c → b → a,最內層先完成,逐層向外返回,最後再執行 jquery 的 factory。全部編譯結束後,callback2 拿到的 args 就是 [moduleA.exports, jQuery],交給 callback1 使用。
要點總結:只要模塊通過 module.exports = xxx 或 exports.xx = xxx 暴露了接口,其他模塊就能用 require("該模塊") 取得並使用;模塊的最終狀態會置為 STATUS.COMPILED。
補充兩點閱讀建議:sea.js 版本迭代後已不再有 _compile 方法,閱讀源碼時對照自己使用的版本;此外司徒正美的《JavaScript 框架設計》難度不低,但精讀之後對前端工程能力的提升很明顯,玉伯的 sea.js 也值得動手實踐。