DIV CSS 佈局教程網

JavaScript 依賴注入完全指南:從概念到實作
編輯:關於JavaScript     

軟體開發的本質,其實就是一個不斷把複雜事物抽象化、再把這些抽象層層組裝起來的過程。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,而我們又想新增第三個依賴,難不成要逐一改寫所有呼叫點?顯然不是好辦法。這正是「依賴注入器」想要解決的痛點。於是我們可以把目標歸納如下:

  1. 要能夠註冊(register)依賴項。
  2. 注入器接收一支函式,並回傳一個能取得所需資源的新函式。
  3. 實作要簡單明瞭,不能搞得太複雜。
  4. 注入器必須保留傳入函式的作用域。
  5. 傳入的函式除了注入的依賴外,還能接收自訂參數。

requirejs / AMD 的做法

你大概聽過大名鼎鼎的 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 轉換成真正的陣列。至此我們的程式碼已能通過測試,但仍有美中不足:每個模組名稱都得寫兩次、順序不能隨意打亂,而且自訂參數永遠被排在所有依賴之後。

反射(reflection)的做法

根據維基百科的解釋,反射指的是程式能在執行過程中檢視並修改自身的結構與行為。放到 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 風格到反射式注入,並最終整合出一個兼顧彈性與抗壓縮的版本。希望這篇文章能成為你踏入依賴注入世界的起點,幫助你寫出更好維護、更具彈性的「依賴注入風格」程式碼。

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