「程式是對複雜性的管理。」電腦世界是一座巨大的抽象建築群,我們包裝一些東西、發布新工具,週而復始。你所使用的語言本身就內建了許多抽象函式與低階運算子——在 JavaScript 裡也是一樣。
遲早你會需要用到其他開發者的抽象成果,也就是依賴別人的程式碼。我喜歡無依賴的模組,但那很難實現;即使是你精心打造的黑盒子元件,多少也會依賴些什麼。這正是依賴注入(Dependency Injection)派上用場的地方。有效地管理依賴,是絕對必要的能力。
var service = function () { return { name: 'Service' }; };
var router = function () { return { name: 'Router' }; };
var doSomething = function (other) {
var s = service(); // 硬寫死,無法替換
var r = router();
};
這段程式碼能跑,但一點都不靈活。如果我們想改用 ServiceXML 或 ServiceJSON 呢?如果要做單元測試、需要注入測試用的假物件呢?總不能每次去改函式本體。
var doSomething = function (service, router, other) {
var s = service();
var r = router();
};
依賴變成參數,確實達到了目的。但這帶來新問題:如果 doSomething 散落在程式各處,一旦依賴條件改變,你得修改所有呼叫它的地方。
define(['service', 'router'], function (service, router) {
// ...
});
先描述需要的依賴,再寫你的函式,參數順序很重要。讓我們做一個 injector 模組,接受相同語法:
var injector = {
dependencies: {},
register: function (key, value) {
this.dependencies[key] = value;
},
resolve: function (deps, func, scope) {
var args = [];
for (var i = 0; i < deps.length; i++) {
var d = deps[i];
if (this.dependencies[d]) {
args.push(this.dependencies[d]);
} else {
throw new Error("Can't resolve " + d);
}
}
return function () {
func.apply(scope || {},
args.concat(Array.prototype.slice.call(arguments, 0)));
};
}
};
injector.register('service', service);
injector.register('router', router);
var doSomething = injector.resolve(['service', 'router'],
function (service, router, other) {
expect(service().name).to.be('Service');
expect(router().name).to.be('Router');
expect(other).to.be('Other');
});
doSomething("Other");
(此處用 expect.js 做斷言,只是為了驗證行為符合預期,帶一點 TDD 的味道。)
scope 是選填的;Array.prototype.slice.call(arguments, 0) 則是必須的,用來把 arguments 轉成真正的陣列。
問題:我們得把所需部件寫兩次(一次在陣列裡、一次在函式簽名上),而且順序不能弄錯。自訂參數永遠排在依賴之後。
依維基百科的定義,反射是指程式在執行時檢查和修改物件結構與行為的能力。在 JavaScript 的語境下,具體來說就是讀取並分析函式的原始碼。
如果你在 console 印出 doSomething.toString(),會得到:
"function (service, router, other) {
var s = service();
var r = router();
}"
這個字串讓我們能遍歷參數,更重要的是能取得它們的名稱——這正是 Angular 實作依賴注入的方式。以下正則表達式借自 Angular 的原始碼:
/^function\s*[^\(]*\(\s*([^\)]*)\)/m
resolve: function () {
var func, deps, scope, args = [], self = this;
func = arguments[0];
deps = func.toString()
.match(/^function\s*[^\(]*\(\s*([^\)]*)\)/m)[1]
.replace(/ /g, '').split(',');
scope = arguments[1] || {};
return function () {
var a = Array.prototype.slice.call(arguments, 0);
for (var i = 0; i < deps.length; i++) {
var d = deps[i];
// 有註冊就用註冊的,否則從呼叫時傳入的參數依序補上
args.push(self.dependencies[d] && d != '' ?
self.dependencies[d] : a.shift());
}
func.apply(scope || {}, args);
};
}
正則的執行結果是 ["function (service, router, other)", "service, router, other"],我們只要第二項。去掉空白並 split 就得到 deps 陣列。唯一的大改變是最後那行:循環時若發現某個依賴沒註冊,就從 arguments 撈一個回來(shift() 在空陣列上回傳 undefined 而非報錯,這點很方便)。
var doSomething = injector.resolve(function (service, other, router) {
expect(service().name).to.be('Service');
expect(router().name).to.be('Router');
expect(other).to.be('Other');
});
doSomething("Other");
不必重寫依賴、順序可以打亂,仍然能正常運作。
這個做法並不完美,而問題正好出在反射這件事本身。程式碼壓縮(minification)會破壞整個邏輯,因為它會把參數改名:
var doSomething = function (e, t, n) { var r = e(); var i = t(); }
參數名變成 e、t、n,我們再也無法對應回正確的依賴。Angular 團隊提出的解法,是回到「明確宣告」:
var doSomething = injector.resolve(['service', 'router', function (service, router) {
// ...
}]);
這看起來跟一開始的方案很像——確實如此。這正是為什麼 Angular 後來強制要求用這種寫法。
var injector = {
dependencies: {},
register: function (key, value) {
this.dependencies[key] = value;
},
resolve: function () {
var func, deps, scope, args = [], self = this;
if (typeof arguments[0] === 'string') {
// 形式一:明確字串宣告,安全對抗壓縮
func = arguments[1];
deps = arguments[0].replace(/ /g, '').split(',');
scope = arguments[2] || {};
} else {
// 形式二:反射推斷,簡潔但懼怕壓縮
func = arguments[0];
deps = func.toString()
.match(/^function\s*[^\(]*\(\s*([^\)]*)\)/m)[1]
.replace(/ /g, '').split(',');
scope = arguments[1] || {};
}
return function () {
var a = Array.prototype.slice.call(arguments, 0);
for (var i = 0; i < deps.length; i++) {
var d = deps[i];
args.push(self.dependencies[d] && d != '' ?
self.dependencies[d] : a.shift());
}
func.apply(scope || {}, args);
};
}
};
兩三個參數時行為等同於前述版本;三個參數時,第一個參數是逗號分隔的字串,會被填進 deps 陣列:
var doSomething = injector.resolve('router,,service', function (a, b, c) {
expect(a().name).to.be('Router');
expect(b).to.be('Other');
expect(c().name).to.be('Service');
});
doSomething("Other");
注意 'router,,service' 中那兩個逗號——這不是筆誤。空值代表「這個位置由呼叫時傳入的參數填補」,也就是佔位符。透過它我們就能控制參數順序。
有時候可以把依賴掛到函式的 this 上,省掉參數宣告:
resolve: function (deps, func, scope) {
var args = [];
scope = scope || {};
for (var i = 0; i < deps.length; i++) {
var d = deps[i];
if (this.dependencies[d]) {
scope[d] = this.dependencies[d]; // 掛到 scope 上
} else {
throw new Error("Can't resolve " + d);
}
}
return function () {
func.apply(scope, Array.prototype.slice.call(arguments, 0));
};
}
var doSomething = injector.resolve(['service', 'router'], function (other) {
expect(this.service().name).to.be('Service');
expect(this.router().name).to.be('Router');
expect(other).to.be('Other');
});
doSomething("Other");
好處是開發者不必再寫依賴參數,它們已經是函式作用域的一部分。
其實我們大多數人都用過依賴注入,只是沒有意識到。即使你不知道這個術語,你很可能已經在程式碼裡用過它無數次。理解它的運作原理,能幫助你在設計模組邊界時做出更好的決定。
最後補充一個現實觀點:在今天的專案中,除非你在寫框架或需要高度可測試性的大型應用,否則 ES6 的 ES Module(import / export)已經提供了足夠的依賴管理機制, bundler 會在編譯期靜態解析依賴圖,效能與可讀性都優於執行期反射。上述手寫 injector 的價值,主要在於理解「為什麼框架要這樣設計」。