軟體開發的本質,其實就是一個不斷把複雜事物抽象化、再把這些抽象層層組裝起來的過程。JavaScript 自然也不例外。當我們動手打造一個應用時,幾乎一定會用到別人寫好的程式碼,像是各種知名的開源庫或框架。隨著專案規模持續膨脹,我們需要依賴的模組也越來越多,這時「如何有效管理這些依賴」就成了一個不可迴避的課題,而依賴注入正是為了解決這個問題而生。
你或許在多數框架或函式庫裡聽過「依賴注入」這個名詞,例如知名前端框架 AngularJS 就把依賴注入當作核心特性之一。但依賴注入並不是什麼新發明,它在 PHP 等其他語言裡早已行之有年,而且它的概念也沒有想像中那麼高深莫測。本文將帶你一步步認識 JavaScript 中的依賴注入,並動手寫出「依賴注入風格」的程式碼。

假設我們手上已經有兩個模組:第一個負責發送 Ajax 請求,第二個則用作路由。程式碼大致如下:
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) {
// ...
});
requirejs 的思路是:先宣告需要哪些模組,再撰寫自己的函式,而參數的順序至關重要。如果我們想打造一個名為 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)頗為相近。
現在正式動手打造 injector。首先讓它成為一個單例(singleton),這樣應用各處都能共用同一套功能:
var injector = {
dependencies: {},
register: function(key, value) {
this.dependencies[key] = value;
},
resolve: function(deps, func, scope) {
}
}
這個物件相當樸素:兩個方法加上一個用來存放依賴的變數。我們要做的是遍歷 deps 陣列,逐一到 dependencies 裡找出對應的資源,最後用 apply 呼叫傳入的 func:
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)));
}
}
如果需要指定作用域,上面的寫法也能正常運作。其中 Array.prototype.slice.call(arguments, 0) 的作用,是把類陣列物件 arguments 轉換成真正的陣列。至此我們的程式碼已能通過測試,但仍有美中不足:每個模組名稱都得寫兩次、順序不能隨意打亂,而且自訂參數永遠被排在所有依賴之後。
根據維基百科的解釋,反射指的是程式能在執行過程中檢視並修改自身的結構與行為。放到 JavaScript 裡,簡單說就是「讀取函式原始碼並加以分析」的能力。還記得剛才的 doSomething 嗎?只要呼叫 doSomething.toString(),就能拿到這樣一段字串:
"function (service, router, other) {
var s = service();
var r = router();
}"
有了這招,我們就能輕鬆取得參數,甚至連參數名稱都一清二楚——這正是 AngularJS 實作依賴注入的方式。在 AngularJS 的原始碼裡,你會看到這段正則表達式:
/^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 陣列。關鍵的改動在這幾行:
var a = Array.prototype.slice.call(arguments, 0);
...
args.push(self.dependencies[d] && d != '' ? self.dependencies[d] : a.shift());
這裡我們遍歷所有依賴項,若其中有用戶自訂的缺口,就從 arguments 補上。當陣列為空時,shift 只會回傳 undefined,而不會拋出錯誤。改寫後的 injector 使用方式如下:
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");
現在,我們可以隨心所欲地打亂依賴的順序了。
然而天下沒有完美的方案。反射式注入有個致命缺陷:一旦程式碼被壓縮(minify),就會出問題。因為壓縮過程會把參數重新命名,導致依賴無法解析,例如:
var doSomething=function(e,t,n){var r=e();var i=t()}
因此我們需要一個折衷方案,就像 AngularJS 那樣,把依賴名稱明確寫成陣列:
var doSomething = injector.resolve(['service', 'router', function(service, router) {
}]);
這與我們最初看到的 AMD 寫法異曲同工。於是我們把兩種思路整合起來,最終版本如下:
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);
}
}
}
這個版本的 resolve 可接受兩個或三個參數。來看看測試:
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");
你可能注意到兩個逗號之間空著——這並不是筆誤。這個空缺,正是留給 Other 參數的位置,也就是我們控制參數順序的關鍵手法。
本文介紹了幾種在 JavaScript 中實作依賴注入的思路,從手動傳參、AMD 風格到反射式注入,並最終整合出一個兼顧彈性與抗壓縮的版本。希望這篇文章能成為你踏入依賴注入世界的起點,幫助你寫出更好維護、更具彈性的「依賴注入風格」程式碼。