有一句話我很喜歡:「程式設計的本質,是對複雜度的管理。」整個軟體世界其實就是一座巨大的抽象大廈——我們不斷地把細節包起來,交出一個又一個工具,然後再往上蓋一層。你每天使用的語言本身,就提供了大量內建的抽象與低階運算子,JavaScript 也不例外。
遲早,你會需要站在別人的肩膀上,也就是依賴他人的程式碼。我个人偏爱零依賴的模組,但現實裡幾乎做不到;即使是那些設計得很漂亮的黑盒子元件,也多少會牽扯到外部的東西。這正是依賴注入(Dependency Injection)登場的時刻。今天,管理依賴的能力幾乎是必備技能。以下整理我在這個問題上的探索與幾種可行方案。
先假設我們手上有兩個模組:一個負責 Ajax 請求的 service,一個負責路由的 router。
var service = function() {
return { name: 'Service' };
};
var router = function() {
return { name: 'Router' };
};
接著有一個函式需要同時用到這兩個模組:
var doSomething = function(other) {
var s = service();
var r = router();
};
程式能跑,但很僵硬。如果哪天要換成 ServiceXML、ServiceJSON,或者想在測試裡塞入假物件(mock)呢?顯然不能靠改函式主體來解決。最直覺的做法是把依賴當參數傳進來:
var doSomething = function(service, router, other) {
var s = service();
var r = router();
};
這樣確實達到了目的,卻換來新麻煩:如果 doSomething 在專案裡被呼叫了幾十次,一旦依賴條件改變,你得改動所有呼叫點。我們需要一個工具,把這件事集中管理——這就是依賴注入試圖解決的問題。
動手之前,先把驗收標準列出來:
你大概聽過 RequireJS,它是處理依賴注入相當成熟的解法:
define(['service', 'router'], function(service, router) {
// ...
});
核心觀念是:先宣告需要哪些依賴,再寫自己的函式,參數順序至關重要。我們可以照著這個語法,寫一個名為 injector 的模組:
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 風格的驗證,只是為了確認行為符合預期。)
先搭出骨架,用單例物件的形式,方便在程式的各個部分共用:
var injector = {
dependencies: {},
register: function(key, value) {
this.dependencies[key] = value;
},
resolve: function(deps, func, scope) {
}
};
接著實作 resolve:檢查 deps 陣列,在 dependencies 裡找出對應物件,最後用 apply 把參數餵給原函式。
resolve: function(deps, func, scope) {
var args = [];
for (var i = 0; i < deps.length, d = deps[i]; 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)
));
};
}
scope 是可選的;Array.prototype.slice.call(arguments, 0) 用來把類陣列物件 arguments 轉成真陣列。測試通過了,但仍有兩個缺陷:依賴名稱要寫兩次,順序不能亂,而且自訂參數永遠被排在依賴後面。
依維基百科的定義,反射(Reflection)是指程式在執行期檢查並修改自身結構與行為的能力。放到 JavaScript 的語境裡,具體做法就是讀取並解析函式的原始碼。
把 doSomething.toString() 印出來,你會得到:
"function (service, router, other) {
var s = service();
var r = router();
}"
這串字裡藏著參數名,而參數名就是我們要的依賴線索——這正是 Angular 實作依賴注入的方式。我偷懶直接借用了 Angular 用來抓參數的正規表達式:
/^function\s*[^\(]*\(\s*([^\)]*)\)/m
於是 resolve 可以改成這樣:
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"]
我們只需要第二項,去掉空白、用逗號切開,就得到 deps 陣列。關鍵改動在這一行:
args.push(self.dependencies[d] && d != '' ? self.dependencies[d] : a.shift());
如果註冊表裡找不到,就從 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");
依賴不必重寫,順序也能任意打亂。我們成功複製了 Angular 的魔法。
但反射法有個致命傷:壓縮(minify)會改掉參數名,映射關係就斷了。例如:
var doSomething = function(e, t, n) {
var r = e();
var i = t();
};
Angular 團隊給出的解法,是回到一開始那種顯式宣告:
var doSomething = injector.resolve(['service', 'router', function(service, router) {
// ...
}]);
我找不到更好的方案,所以決定把兩種寫法合起來,做成最終版:
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);
};
}
};
傳兩個參數時行為等同於反射版;傳三個參數時,第一個參數會被當成依賴描述字串。測試如下:
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' 中間有兩個逗號——這不是筆誤。空值代表佔位符,對應到 other 參數,我們就是靠這個機制控制參數順序。
有時候我會需要第三個變數來操作函式的作用域,也就是 this。做法很簡單:把依賴掛到 scope 物件上。
resolve: function(deps, func, scope) {
var args = [];
scope = scope || {};
for (var i = 0; i < deps.length, d = deps[i]; i++) {
if (this.dependencies[d]) {
scope[d] = this.dependencies[d];
} 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");
其實大多數人都用過依賴注入,只是沒有意識到這個名詞。就算你從沒聽過它,你很可能已經在自己的程式碼裡用過無數次。希望這篇文章能讓你對它的理解更深一層。