DIV CSS 佈局教程網

深入 JavaScript 依賴注入:從手動傳參到自動解析
編輯:JavaScript綜合知識     

有一句話我很喜歡:「程式設計的本質,是對複雜度的管理。」整個軟體世界其實就是一座巨大的抽象大廈——我們不斷地把細節包起來,交出一個又一個工具,然後再往上蓋一層。你每天使用的語言本身,就提供了大量內建的抽象與低階運算子,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 在專案裡被呼叫了幾十次,一旦依賴條件改變,你得改動所有呼叫點。我們需要一個工具,把這件事集中管理——這就是依賴注入試圖解決的問題。

二、先定義目標

動手之前,先把驗收標準列出來:

  1. 能夠註冊依賴關係。
  2. 注入機制接受一個函式,並回傳一個可直接使用的函式。
  3. 程式碼要精簡,語法要漂亮,不能寫一大堆樣板。
  4. 必須保留被傳遞函式原本的作用域。
  5. 被傳遞的函式除了依賴之外,還能接受自訂參數。

三、RequireJS / AMD 的思路

你大概聽過 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");

結語

其實大多數人都用過依賴注入,只是沒有意識到這個名詞。就算你從沒聽過它,你很可能已經在自己的程式碼裡用過無數次。希望這篇文章能讓你對它的理解更深一層。

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