DIV CSS 佈局教程網

namespace.js 源碼導讀:用佇列驅動的命名空間載入器
編輯:關於JavaScript     

專案地址:https://github.com/hirokidaichi/namespace-js

這個庫不到 210 行,卻把「定義命名空間、宣告依賴、非同步載入」三件事串成的一條流程做得相當完整。以下按物件拆解。

Namespace 物件

對外暴露的 Namespace 本身是一個函式:

var createNamespace = function(fqn){
return new NamespaceDefinition(
NamespaceObjectFactory.create(fqn || 'main')
);
};
merge(createNamespace, {
'Object' : NamespaceObjectFactory,
Definition: NamespaceDefinition,
Proc : createProcedure
});

呼叫它就會得到一個 NamespaceDefinition 實例;不傳參數時預設使用 main 命名空間。同時掛上去的三個屬性分別是 NamespaceObjectFactory、NamespaceDefinition 與 createProcedure,供進階用法直接取用。

Procedure:一個極簡的任務佇列

整個庫的執行流程都靠它推動。它只有三個屬性——state(狀態)、steps(佇列)、_status(初始為 init),以及五個方法:

var Procedure = function _Private_Class_Of_Proc(){
merge(this, {
state : {},   // 狀態
steps : [],   // 存儲狀態的數組
_status: 'init'
});
};
merge(Procedure.prototype, {
next: function(state){        // 有值則從隊尾入列,然後回傳 this 以支援鏈式
if(state) this.enqueue(state);
return this;
},
isRunning: function(){ return (this._status === 'running'); },
enqueue: function(state){ this.steps.push(state); },  // 隊尾入列
dequeue: function(){ return this.steps.shift(); },    // 隊頭出列
call: function(initialState, callback){
if( this.isRunning() ) throw("do not run twice");
this.state = initialState || {};   // 保存當前 state
this.enqueue(function($c){         // 收尾用的函式入列
$c();
if(callback)callback(this);
});
this._status = 'running';
this._invoke();
},
_invoke: function(){
var _self = this;
var step = _self.dequeue();        // 物件出列(FIFO)
if( !step ){ _self._status = 'finished'; return; }
if( step.call ) {                  // 是函式物件時,指定 this 為 state 並在回呼中續跑
return step.call( _self.state,function _cont(state){
if( state ) _self.state = state;
_self._invoke();
});
}
var finishedProcess = 0;
if( step.length === 0 ) _self._invoke();   // 空陣列直接續跑
for(var i =0,l=step.length;i<l;i++){       // 陣列則是「並列任務」
step[i].call(_self.state,function _joinWait(){
finishedProcess++;
if( finishedProcess == l ){ _self._invoke(); }
});
}
}
});

var createProcedure = function(state) {
return new Procedure().next(state);
};

兩個設計值得注意。第一,_invoke 會分辨 step 是函式還是陣列:函式代表一個連續步驟,陣列則代表一組並列依賴,必須等全部都呼叫過回呼(finishedProcess == l)才繼續往下。第二,每個 step 都以 _self.state 作為 this 呼叫,並透過回呼參數把狀態交回佇列——這讓非同步操作(例如 Ajax)能自然嵌進流程裡。

NamespaceObject:命名空間的實際載體

var NamespaceObject = function _Private_Class_Of_NamespaceObject(fqn){
merge(this, {
stash: { CURRENT_NAMESPACE : fqn },  // 記錄當前 namespace
fqn : fqn,
proc : createProcedure()
});
};
merge(NamespaceObject.prototype, {
enqueue: function(context) { this.proc.next(context); },
call: function(state,callback) { this.proc.call(state, callback); },
valueOf: function() { return "#NamespaceObject<" + this.fqn + ">"; },
merge: function(obj) { merge(this.stash,obj); return this; },
getStash: function() { return this.stash; },
getExport: function(importName) {
if (importName === '*') return this.stash;
var importNames = importName.split(/,/),
retStash = {};
for(var i = 0,l=importNames.length;i<l;i++){
retStash[ importNames[i] ] = this.stash[ importNames[i] ];
}
return retStash;
}
});
var NamespaceObjectFactory = (function() {
var cache = {};
return {
create :function(fqn){
_assertValidFQN(fqn);
return (cache[fqn] || (cache[fqn] = new NamespaceObject(fqn)));
}
};
})();

stash 是這個命名空間真正存放成員的地方。NamespaceObjectFactory 用閉包裡的 cache 確保同一個 fqn 只會有一個 NamespaceObject——這是整個模組系統能運作的前提:如果 a.js 與 b.js 各自 provide 到不同的物件上,依賴就永遠對不上了。

getExport 則實作了「選擇性匯出」:'*' 匯出全部,或傳入逗號分隔的名單只匯出指定成員。

NamespaceDefinition:核心

var NamespaceDefinition = function _Private_Class_Of_NamespaceDefinition(nsObj) {
merge(this, {
namespaceObject: nsObj,
requires : [],
useList : [],
stash : {},
defineCallback : undefined
});
var _self = this;
nsObj.enqueue(function($c){ _self.apply($c); });   // 把自己的 apply 排進 NamespaceObject 的佇列
};
merge(NamespaceDefinition.prototype, {
use: function(syntax){
this.useList.push(syntax);
var splitted = syntax.split(/\s+/);
var fqn = splitted[0];        // 取得 namespace
var importName = splitted[1]; // 取得 namespace 中的對象
_assertValidFQN(fqn);
this.requires.push(function($c){   // 放一個函數到 requires 數組中
var context = this;
var require = NamespaceObjectFactory.create(fqn);
require.call(this,function(state){
context.loadImport(require,importName);
$c();
});
});
return this;
},
_mergeStashWithNS: function(nsObj){
var nsList = nsObj.fqn.split(/\./);
var current = this.getStash();
for(var i = 0,l=nsList.length;i<l-1;i++){
if( !current[nsList[i]] ) current[nsList[i]] = {};
current = current[nsList[i]];
}
var lastLeaf = nsList[nsList.length-1];
current[lastLeaf] = merge(current[lastLeaf] || {}, nsObj.getStash());
},
loadImport: function(nsObj,importName){
if( importName ){
merge( this.stash, nsObj.getExport(importName) );
}else{
this._mergeStashWithNS( nsObj );
}
},
define: function(callback){
var nsDef = this, nsObj = this.namespaceObject;
this.defineCallback = function($c) {
var ns = {
provide : function(obj){
nsObj.merge(obj);
$c();
}
};
merge(ns, nsDef.getStash());
merge(ns, nsObj.getStash());
callback(ns);
};
},
getStash: function(){ return this.stash; },
valueOf: function(){ return "#NamespaceDefinition<"+this.namespaceObject+"> uses :" + this.useList.join(','); },
apply: function(callback){
var nsDef = this;
createProcedure(nsDef.requires)
.next(nsDef.defineCallback)
.call(nsDef,function(){
callback( nsDef.getStash() );
});
}
});

建構子最後那行是關鍵:nsObj.enqueue(...) 把自己的 apply 排進 NamespaceObject 的佇列。也就是說,define 只是排隊,不是執行。等到有人真的 use 這個命名空間、觸發 NamespaceObject 的 call,佇列才開始跑。

use 做的事是把一個函式推進 requires 陣列,這個函式會去取得對應的 NamespaceObject 並呼叫它的 call——如果對方還沒載入,就在那裡等;載入完成後再把匯出的成員併進自己的 stash。

載入途徑

庫尾擴充了四個方法:

Namespace.use = function(useSyntax){ return Namespace().use(useSyntax); }
Namespace.fromInternal = Namespace.GET = ...  // 用 XHR 取回原始碼後 eval
Namespace.fromExternal = ...                   // 用 script 標籤載入

GET 的實作把各年代的 XHR 建構方式層層包在 try/catch 裡,並用 isSuccessStatus 判斷回應——其中特意把 file: 與 chrome: 協議下 status 為 0 的情況也算成功,方便在本機直接開檔除錯。

fromExternal 則動態建立 script 元素,同時掛 onload 與 IE 的 onreadystatechange,並用一個 loaded 旗標防止兩者重複觸發回呼。

完整流程走一遍

Namespace('logtest')
.define(function (ns) {
console.log(2);
ns.provide({
log : function () { console.log(3); }
});
});

console.log(4);

Namespace
.use('logtest')
.apply( function (ns) {
console.log(5);
ns.logtest.log();
});

1. Namespace('logtest') 等於 new NamespaceDefinition(NamespaceObjectFactory.create('logtest')),接著呼叫 define 只是給 defineCallback 賦值——此時什麼都還沒發生。

2. Namespace.use('logtest') 等於 Namespace().use('logtest'),也就是在 main 這個 NamespaceDefinition 上宣告依賴,requires 陣列多了一個函式。

3. .apply(callback) 取出 requires 生成 Procedure 並入列,接著把 defineCallback(此例中為 undefined)也入列,然後呼叫 call。

4. 佇列開始跑:先執行 requires 裡的函式,它呼叫 logtest 這個 NamespaceObject 的 call,於是 logtest 自己的佇列啟動,跑到當初 enqueue 的 apply,把定義好的 defineCallback 放進它自己的 Procedure 並執行——這一刻 console.log(2) 才印出來,provide 也才把 log 寫進 NamespaceObject 的 stash。

5. logtest 完成後回呼,loadImport 把 stash 併進 main 的 stash,$c() 讓 main 的佇列繼續,最後執行 .apply() 傳入的函式,印出 5 與 3。

所以實際的輸出順序是 4、2、5、3,而不是程式碼的字面順序。

使用要點

定義時,所有實作都放在 define 的匿名函式裡,並用 ns.provide({...}) 對外公開成員:

function (ns) {
// 具體的實現
// 定義對外公開的對象,外部 use 該 nsName 之後,就可以通過 ns.nsName.key() 來調用它
ns.provide({ key : value });
}

這帶來一個實際好處:所有的定義都是延遲的——只有在真正被使用時才解析與執行。這與今天 ES Module 的動態 import()、以及 AMD 的 define/require 是同一思路的不同實作。

最後要說明的是,define 與 use 之間透過 Procedure 佇列傳遞狀態的細節並不容易一眼看穿,我自己也還沒完全整理清楚,這篇就先到這裡,日後有時間再補。

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