Javascript依赖注入我们了解不够多了，今天小编为各位整理一篇关于Javascript依赖注入学习笔记，希望这篇文章能够对各位有用。

注意：不要将依赖注入和设计模式里的依赖倒置原则（Dependency Inversion Principle）混淆。

目标

设想我们有两个模块。第一个是负责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呢,或者如果我们需要一些测试模块呢。我们不能仅靠编辑函数体来解决问题。首先，我们可以通过函数的参数来解决依赖性。即：

var doSomething = function(service, router, other) { 
    var s = service();
    var r = router();
};

我们通过传递额外的参数来实现我们想要的功能，然而，这会带来新的问题。想象如果我们的doSomething方法散落在我们的代码中。如果我们需要更改依赖条件，我们不可能更改所有调用函数的文件。

我们需要一个能帮我们搞定这些的工具。这就是依赖注入尝试解决的问题。让我们写下一些我们的依赖注入解决办法应该达到的目标：

我们应该能够注册依赖关系
注入应该接受一个函数，并返回一个我们需要的函数
我们不能写太多东西——我们需要精简漂亮的语法
注入应该保持被传递函数的作用域
被传递的函数应该能够接受自定义参数，而不仅仅是依赖描述
堪称完美的清单，下面 让我们实现它。
RequireJS / AMD的方法
你可能对RequireJS早有耳闻，它是解决依赖注入不错的选择。

define(['service', 'router'], function(service, router) { 
    // ...
});

这种想法是先描述需要的依赖，然后再写你的函数。这里参数的顺序很重要。如上所说，让我们写一个叫做injector的模块，能接受相同的语法。

var doSomething = injector.resolve(['service', 'router'], function(service, router, other) { 
    console.log(service().name); //Service
    console.log(router().name);  //Router
    console.log(other().name);   //Other
});
doSomething(other); 

下面开始我们的injector模块，这是非常棒的一个单例模式，所以它能在我们程序的不同部分工作的很好。

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)));
    }       
}

scope是可选的，Array.prototype.slice.call(arguments, 0)是必须的，用来将arguments变量转换为真正的数组。到目前为止还不错。我们的测试通过了。这种实现的问题是，我们需要写所需部件两次，并且我们不能混淆他们的顺序。附加的自定义参数总是位于依赖之后。

反射方法
根据维基百科的定义反射是指一个程序在运行时检查和修改一个对象的结构和行为的能力。简单的说，在JavaScript的上下文里，这具体指读取和分析的对象或函数的源代码。让我们完成文章开头提到的doSomething函数。如果你在控制台输出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数组。只有一个大的改变：

var a = Array.prototype.slice.call(arguments, 0); 
...
args.push(self.dependencies[d] && d != '' ? self.dependencies[d] : a.shift());