DIV CSS 佈局教程網

動手寫一個瀏覽器端 JS 模塊加載器:原理與循環依賴難題
編輯:關於JavaScript     

在 ES6 之前,JavaScript 並不像其他語言那樣自帶成熟的模塊機制。頁面只能靠一個個 <script> 標籤把自有代碼和第三方庫依次引入,稍不留神就會撞}}"上全局命名衝突。整個 JS 社區為此做了大量嘗試,設法在當時的運行環境裡「拼」出模塊的效果。

歷史上流傳最廣的兩套規範是 CommonJS 與 AMD:前者服務於 Node 環境,後者在瀏覽器側由 Require.js 等項目落地。此外還有國內開源的 Sea.js,遵循 CMD 規範。(隨著 ES6 普及,這些方案如今多已停止維護,無論 AMD 還是 CMD,都逐漸成為一段歷史。)

加載器的四個核心步驟

寫一個堪用的 JS 加載器並不複雜,拆開來看就是:解析路徑 → 下載模塊 → 解析依賴 → 執行模塊。

先約定什麼叫「模塊」。在各家規範中,通常一個 js 文件即代表一個模塊。於是我們可以在模塊文件裡構造一個閉包,並對外導出一個對象:

 define(factory() { var x = { a: 1 }; return x; });

define 接收一個工廠函數,瀏覽器執行該腳本時,define 會調用 factory,把它的返回值存進加載器的模塊表 modules 中。

那麼如何唯一標識一個模塊?答案很自然——文件的 URI。它天生就是唯一的 id。

路徑的幾種形態

  • 絕對路徑:https://xxx、file://xxx
  • 相對路徑:./xxx、../xxx,或直接寫文件名(相對於當前頁面)
  • 虛擬絕對路徑:/xxx,此處的 / 代表站點根目錄

因此必須有一個 resolvePath 函數,以當前頁面路徑為基準,把各種形態的 path 統一解析成 URI。

用觀察者模式串起依賴

假設我們要引用 a.js 與 b.js,並希望兩者都就緒後再執行回調函數 f。做法是建立一個 eventProxy,訂閱「a 加載完成」與「b 加載完成」兩個事件;define 執行到最後、把導出掛上 modules 之後,就 emit 一個「本模塊已加載」的事件。eventProxy 收到後檢查 a 與 b 是否都到齊,齊了就把它們作為參數傳給 f 執行。

同一套機制也能用來處理模塊間的依賴聲明:

 // a.js define([ 'c.js', 'd.js' ], factory (c, d) { var x = c + d; return x; });

此時 define 的第一個參數是依賴數組,表示 a 依賴 c 與 d。define 執行時先讓 eventProxy 訂閱 c 與 d,等它們就緒後再執行回調、存下 a 的導出,並 emit「a 已加載」。

異步加載的關鍵差異

瀏覽器加載腳本最原始的方式,就是插入一個 <script> 標籤並指定 src。加載器裡的模塊下載,正是用 DOM 操作來完成:插入標籤、設定 src,此時該模塊處於「下載中」狀態。

值得留意的是,動態插入 script 與初次解析頁面 DOM 時的 script 行為並不相同:

初次加載時,瀏覽器自上而下解析 DOM,遇到 script 便下載並阻塞解析,等腳本下載、執行完畢才繼續往下走(現代瀏覽器有 preload 優化,會提前下載多個腳本,但執行順序仍與 DOM 中的先後一致,執行時依然阻塞解析)。

而動態插入時:

var a = document.createElement('script'); a.src='xxx'; document.body.appendChild(a);

瀏覽器會在腳本下載完成後執行它,整個過程是異步的。

下載完成後的整體流程就是:解析依賴 → 加載依賴 → 執行本模塊 → 標記完成 → 觸發回調。

還有一個細節:模塊下載完畢後,解析時如何知道它的 URI?有兩種做法,一是透過 script.onload 取 this.src;二是在 define 內部使用 document.currentScript.src。

參考實現

核心功能寫下來不到 200 行:

 var zmm = { _modules: {}, _configs: { // 用於拼接相對路徑 basePath: (function (path) { if (path.charAt(path.length - 1) === '/') { path = path.substr(0, path.length - 1); } return path.substr(path.indexOf(location.host) + location.host.length + 1); })(location.href), // 用於拼接相對根路徑 host: location.protocol + '//' + location.host + '/' } }; zmm.hasModule = function (_uri) { // 判斷是否已有該模塊,不論加載中或已加載好 return this._modules.hasOwnProperty(_uri); }; zmm.isModuleLoaded = function (_uri) { // 判斷該模塊是否已加載好 return !!this._modules[_uri]; }; zmm.pushModule = function (_uri) { // 新模塊占坑,但此時還未加載完成,表示加載中;防止重復加載 if (!this._modules.hasOwnProperty(_uri)) { this._modules[_uri] = null; } }; zmm.installModule = function (_uri, mod) { this._modules[_uri] = mod; }; zmm.load = function (uris) { var i, nsc; for (i = 0; i < uris.length; i++) { if (!this.hasModule(uris[i])) { this.pushModule(uris[i]); // 開始加載 var nsc = document.createElement('script'); nsc.src = uri; document.body.appendChild(nsc); } } }; zmm.resolvePath = function (path) { // 返回絕對路徑 var res = '', paths = [], resPaths; if (path.match(/.*:\/\/.*/)) { // 絕對路徑 res = path.match(/.*:\/\/.*?\//)[0]; // 協議+域名 path = path.substr(res.length); } else if (path.charAt(0) === '/') { // 相對根路徑 /開頭 res = this._configs.host; path = path.substr(1); } else { // 相對路徑 ./或../開頭或直接文件名 res = this._configs.host; resPaths = this._configs.basePath.split('/'); } resPaths = resPaths || []; paths = path.split('/'); for (var i = 0; i < paths.length; i++) { if (paths[i] === '..') { resPaths.pop(); } else if (paths[i] === '.') { // do nothing } else { resPaths.push(paths[i]); } } res += resPaths.join('/'); return res; }; var define = zmm.define = function (dependPaths, fac) { var _uri = document.currentScript.src; if (zmm.isModuleLoaded(_uri)) { return; } var factory, depPaths, uris = []; if (arguments.length === 1) { factory = arguments[0]; // 掛載到模塊組中 zmm.installModule(_uri, factory()); // 告訴proxy該模塊已裝載好 zmm.proxy.emit(_uri); } else { // 有依賴的情況 factory = arguments[1]; // 裝載完成的回調函數 zmm.use(arguments[0], function () { zmm.installModule(_uri, factory.apply(null, arguments)); zmm.proxy.emit(_uri); }); } }; zmm.use = function (paths, callback) { if (!Array.isArray(paths)) { paths = [paths]; } var uris = [], i; for (i = 0; i < paths.length; i++) { uris.push(this.resolvePath(paths[i])); } // 先注冊事件,再加載 this.proxy.watch(uris, callback); this.load(uris); }; zmm.proxy = function () { var proxy = {}; var taskId = 0; var taskList = {}; var execute = function (task) { var uris = task.uris, callback = task.callback; for (var i = 0, arr = []; i < uris.length; i++) { arr.push(zmm._modules[uris[i]]); } callback.apply(null, arr); }; var deal_loaded = function (_uri) { var i, k, task, sum; // 當一個模塊加載完成時,遍歷當前任務棧 for (k in taskList) { if (!taskList.hasOwnProperty(k)) { continue; } task = taskList[k]; if (task.uris.indexOf(_uri) > -1) { // 查看這個任務中的模塊是否都已加載好 for (i = 0, sum = 0; i < task.uris.length; i++) { if (zmm.isModuleLoaded(task.uris[i])) { sum ++; } } if (sum === task.uris.length) { // 都加載完成 刪除任務 delete(taskList[k]); execute(task); } } } }; proxy.watch = function (uris, callback) { // 先檢查一遍是否都加載好了 for (var i = 0, sum = 0; i < uris.length; i++) { if (zmm.isModuleLoaded(uris[i])) { sum ++; } } if (sum === uris.length) { execute({ uris: uris, callback: callback }); } else { // 訂閱新加載任務 var task = { uris: uris, callback: callback }; taskList['' + taskId] = task; taskId ++; } }; proxy.emit = function (_uri) { console.log(_uri + ' is loaded!'); deal_loaded(_uri); }; return proxy; }(); 

循環依賴:瀏覽器端

「循環加載」指的是 a 依賴 b、而 b 又依賴 a。這是一種理應盡量避免的設計。用上面的 zmm 加載:

 // main.html zmm.use('/a.js', function(){...}); // a.js define('/b.js', function(b) { var a = 1; a = b + 1; return a; }); // b.js define('/a.js', function(a) { var b = a + 1; return b; });

結果就是 a 等 b、b 等 a 的死鎖。Sea.js 遇到同樣情形也是死鎖,某種程度上它默認這種寫法不該出現。

Sea.js 可以靠 require.async 緩解,但代價是必須改寫 a.js:

 // a.js define('./js/a', function (require, exports, module) { var a = 1; require.async('./b', function (b) { a = b + 1; module.exports = a; //a= 3 }); module.exports = a; // a= 1 }); // b.js define('./js/b', function (require, exports, module) { var a = require('./a'); var b = a + 1; module.exports = b; }); // main.html seajs.use('./js/a', function (a) { console.log(a); // 1 });

問題在於,a 必須事先知道自己會被 b 依賴,而且 use 拿到的是 b 尚未加載時的 a 值,後續變化它無從得知。在瀏覽器端,這個問題似乎沒有優雅的解法。

循環依賴:Node / CommonJS

CommonJS 模塊的重要特性是「加載時執行」——require 的那一刻腳本就會全部跑完。它的處理策略是:一旦出現循環加載,就只導出已經執行的部分,未執行的暫不導出。

 // a.js var a = 1; module.exports = a; var b = require('./b'); a = b + 1; module.exports = a; // b.js var a = require('./a'); var b = a + 1; module.exports = b; // main.js var a = require('./a'); console.log(a); //3

逐步拆解:main.js 先加載 a,此時內存中掛著 a,其 exports 為空對象;接著執行 a.js,在 var b = require('./b') 之前 a.exports 已等於 1;於是轉去執行 b.js,b 拿到的 a.exports 就是 1,算完後把控制權交回 a.js;最終 a 的導出為 3。

兩者的差異源自環境:Node 加載的都是本地模塊,走的是同步流程,遇到依賴就跳進去加載、加完再回到調用點繼續;瀏覽器加載 script 受限於天生設計,只能異步加載、靠回調串接。

循環依賴:ES6

ES6 模塊的運行機制與 CommonJS 根本不同。遇到 import 時它並不執行模塊,只生成一個引用;真正用到時才去模塊裡取值。因此 ES6 模塊是動態引用,不存在取值快照問題,模塊內的變量也始終綁定在其所屬模塊上。

這使得 ES6 對待循環加載的態度完全不一樣:它根本不關心是否發生了循環,只生成指向對方的引用,能否取到值由開發者自己保證。

 // even.js import { odd } from './odd'; export var counter = 0; export function even(n) { counter++; return n == 0 || odd(n - 1);} // odd.js import { even } from './even'; export function odd(n) { return n != 0 && even(n - 1);} // main.js import * as m from './even.js'; m.even(10); // true; m.counter = 6

even.js 中的 even 接收參數 n,只要不為 0 就減 1 並轉交 odd() 判斷;odd.js 同理反向調用。參數 n 從 10 遞減到 0 的過程中,函數共執行 6 次,因此 counter 為 6;若以 20 起始則執行 11 次,累加後為 17。

同樣的例子改寫成 CommonJS 就完全跑不起來:

 // even.js var odd = require('./odd'); var counter = 0; exports.counter = counter; exports.even = function(n) { counter++; return n == 0 || odd(n - 1); } // odd.js var even = require('./even').even; module.exports = function(n) { return n != 0 && even(n - 1); } // main.js var m = require('./even'); m.even(10); // TypeError: even is not a function

因為 even.js 加載 odd.js、odd.js 又回頭加載 even.js,形成循環。此時執行引擎只導出 even.js 已執行的部分(實際上什麼都沒有),所以 odd.js 裡的 even 是 undefined,後續調用自然報錯。

以上就是本次整理的完整內容,希望對你的學習或工作有所幫助;有疑問歡迎留言交流。

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