javascript中的依赖注入【转】

时间 2019-11-08

原文原文链接

原本打算写篇文章介绍下控制反转的常见模式-依赖注入。在翻看资料的时候，发现了一篇好文Dependency injection in JavaScript，就不本身折腾了，结合本身理解翻译一下，好文共赏。javascript

我喜欢引用这样一句话‘编程是对复杂性的管理’。可能你也听过计算机世界是一个巨大的抽象结构。咱们简单的包装东西并重复的生产新的工具。思考那么一下下，咱们使用的编程语言都包括内置的功能，这些功能多是基于其余低级操做的抽象方法，包括咱们是用的javascript。
早晚，咱们都会须要使用别的开发者开发的抽象功能，也就是咱们要依赖其余人的代码。
我但愿使用没有依赖的模块，显然这是很难实现的。即便你建立了很好的像黑盒同样的组件，但总有个将全部部分合并起来的地方。
这就是依赖注入起做用的地方，当前来看，高效管理依赖的能力是迫切须要的，本文总结了原做者对这个问题的见解。html

目标

假设咱们有两个模块，一个是发出ajax请求的服务，一个是路由：java

var service = function() {
    return { name: 'Service' };
}
var router = function() {
    return { name: 'Router' };
}

下面是另外一个依赖了上述模块的函数：ajax

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函数在不少地方被调用，若是有第三个依赖条件，咱们不能改变全部的调用doSomething的地方。
举个小栗子：
假如咱们有不少地方用到了doSomething：编程

//a.js
var a = doSomething(service,router,1)
//b.js 
var b = doSomething(service,router,2)
// 假如依赖条件更改了，即doSomething须要第三个依赖，才能正常工做
// 这时候就须要在上面不一样文件中修改了，若是文件数量够多，就不合适了。
var doSomething = function(service, router, third,thother) {
    var s = service();
    var r = router();
    //***
};

所以，咱们须要一个帮助咱们来管理依赖的工具。这就是依赖注入器想要解决的问题，先看一下咱们想要达到的目标：数组

能够注册依赖
注入器应该接受一个函数而且返回一个已经得到须要资源的函数
咱们不该该写复杂的代码，须要简短优雅的语法
注入器应该保持传入函数的做用域
被传入的函数应该能够接受自定义参数，不只仅是被描述的依赖。
看起来比较完美的列表就如上了，让咱们来尝试实现它。app

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

这里稍微停顿一下，解释一下doSomething的函数体，使用expect.js来做为断言库来确保个人代码能像指望那样正常工做。体现了一点点TDD（测试驱动开发）的开发模式。

下面是咱们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(类数组)转换成真正的数组。
目前来看很不错的，能够经过测试。当前的问题时，咱们必须写两次须要的依赖，而且顺序不可变更，额外的参数只能在最后面。

反射实现

从维基百科来讲，反射是程序在运行时能够检查和修改对象结构和行为的一种能力。
简而言之，在js的上下文中，是指读取而且分析对象或者函数的源码。看下开头的doSomething，若是使用doSomething.toString() 能够获得下面的结果。

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

这种将函数转成字符串的方式赋予咱们获取预期参数的能力。而且更重要的是，他们的name。
下面是Angular依赖注入的实现方式，我从Angular那拿了点能够获取arguments的正则表达式：

/^function\s*[^\(]*\(\s*([^\)]*)\)/m

这样咱们能够修改resolve方法了：

这里，我将测试例子拿上来应该更好理解一点。

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

继续来看咱们的实现。

resolve: function() {
    // agrs 传给func的参数数组，包括依赖模块及自定义参数
    var func, deps, scope, args = [], self = this;
    // 获取传入的func，主要是为了下面来拆分字符串
    func = arguments[0];
    // 正则拆分，获取依赖模块的数组
    deps = func.toString().match(/^functions*[^(]*(s*([^)]*))/m)[1].replace(/ /g, '').split(',');
    //待绑定做用域，不存在则不指定
    scope = arguments[1] || {};
    return function() {
        // 将arguments转为数组
        // 即后面再次调用的时候，doSomething("Other");   
        // 这里的Other就是a，用来补充缺失的模块。
        var a = Array.prototype.slice.call(arguments, 0);
        //循环依赖模块数组
        for(var i=0; i<deps.length; i++) {
            var d = deps[i];
            // 依赖队列中模块存在且不为空的话，push进参数数组中。
            // 依赖队列中不存在对应模块的话从a中取第一个元素push进去(shift以后，数组在改变)
            args.push(self.dependencies[d] && d != '' ? self.dependencies[d] : a.shift());
        }
        //依赖当作参数传入
        func.apply(scope || {}, args);
    }        
}

使用这个正则来处理函数时，能够获得下面结果：

["function (service, router, other)", "service, router, other"]

咱们须要的只是第二项，一旦咱们清除数组并拆分字符串，咱们将会获得依赖数组。主要变化在下面：

var a = Array.prototype.slice.call(arguments, 0);

...

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的魔力。
然而，这并不完美，压缩会破坏咱们的逻辑，这是反射注入的一大问题。由于压缩改变了参数的名称因此咱们没有能力去解决这些依赖。例如：

// 显然根据key来匹配就是有问题的了

var doSomething=function(e,t,n){var r=e();var i=t()}

Angular团队的解决方案以下：

var doSomething = injector.resolve(['service', 'router', function(service, router) {

}]);

看起来就和开始的require.js的方式同样了。做者我的不能找到更优的解决方案，为了适应这两种方式。最终方案看起来以下：

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接受两或者三个参数，若是是两个就是咱们写的第一种了，若是是三个，会将第一个参数解析并填充到deps。
下面就是测试例子(我一直认为将这段例子放在前面可能你们更好阅读一些。)：

// 缺失了一项模块other
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');
});
// 这里传的Other将会用来拼凑
doSomething("Other");

可能会注意到argumets[0]中确实了一项，就是为了测试填充功能的。

直接注入做用域
有时候，咱们使用第三种的注入方式，它涉及到函数做用域的操做(或者其余名字，this对象)，并不常用

var injector = {
    dependencies: {},
    register: function(key, value) {
        this.dependencies[key] = value;
    },
    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上
                //这样就能够直接在函数做用域中调用了
                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");

结束语
依赖注入是咱们全部人都作过的事情中的一种，可能没有意识到罢了。即便没有听过，你也可能用过不少次了。
经过这篇文章对于这个熟悉而又陌生的概念的了解加深了很多，但愿能帮助到有须要的同窗。最后我的能力有限，翻译有误的地方欢迎你们指出，共同进步。
再次感谢原文做者原文地址

如水穿石，厚积才可薄发

原文连接：https://www.cnblogs.com/pqjwy...