DIV CSS 佈局教程網

《JavaScript 框架設計》讀書筆記:模塊加載系統源碼剖析
編輯:關於JavaScript     

模塊化的本質是把 JS 拆分成多個職責單一的單元,便於開發與維護;而模塊加載系統要解決的,是如何按依賴關係把它們正確、高效地取回來並執行。本文以 sea.js 為例,梳理一次完整的加載流程。

前置知識:動態加載 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 與 _use

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 判斷資源狀態

_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 的去重機制

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 解析依賴

腳本下載完成後執行的是 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 觸發時再關聯到具體模塊。

第五步:_compile 編譯與執行

當所有模塊都進入 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 也值得動手實踐。

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