DIV CSS 佈局教程網

JavaScript 依賴注入的三種實作思路
編輯:JavaScript綜合知識     

「程式是對複雜性的管理。」電腦世界是一座巨大的抽象建築群,我們包裝一些東西、發布新工具,週而復始。你所使用的語言本身就內建了許多抽象函式與低階運算子——在 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 散落在程式各處,一旦依賴條件改變,你得修改所有呼叫它的地方。

我們需要的工具,應該做到什麼

  1. 能註冊依賴關係。
  2. 注入時接受一個函式,回傳我們需要的函式。
  3. 語法精簡漂亮,不能寫太多樣板程式碼。
  4. 必須保持被傳遞函式的作用域。
  5. 被傳遞的函式應該能接受自訂參數,而不只是依賴描述。

思路一:RequireJS / AMD 風格

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 轉成真正的陣列。

問題:我們得把所需部件寫兩次(一次在陣列裡、一次在函式簽名上),而且順序不能弄錯。自訂參數永遠排在依賴之後。

思路二:反射(Reflection)

依維基百科的定義,反射是指程式在執行時檢查和修改物件結構與行為的能力。在 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' 中那兩個逗號——這不是筆誤。空值代表「這個位置由呼叫時傳入的參數填補」,也就是佔位符。透過它我們就能控制參數順序。

另一種玩法:直接注入 scope

有時候可以把依賴掛到函式的 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 的價值,主要在於理解「為什麼框架要這樣設計」。

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