当前位置: 澳门新濠3559 > 操作系统 > 正文

但是这种方法拿到的并不是那个单例对象,}我们

时间:2019-12-21 19:57来源:操作系统
有这么一个单例类,位于项目A模块: 本文主要介绍了JavaScript利用闭包实现模块化的方法。 迟早你需要用到其他开发人员的抽象成果——即你依靠别人的代码。我喜欢依赖自由的模块,

有这么一个单例类,位于项目A模块:

本文主要介绍了JavaScript利用闭包实现模块化的方法。

迟早你需要用到其他开发人员的抽象成果——即你依靠别人的代码。我喜欢依赖自由的模块,但那是难以实现的。甚至你创建的那些漂亮的黑盒子组件也或多或少会依赖一些东西。这正是依赖注入大显身手的之处。现在有效地管理依赖的能力是绝对必要的。本文总结了我对问题探索和一些的解决方案。

计算机编程的世界其实就是一个将简单的部分不断抽象,并将这些抽象组织起来的过程。JavaScript也不例外,在我们使用JavaScript编写应用时,我们是不是都会使用到别人编写的代码,例如一些着名的开源库或者框架。随着我们项目的增长,我们需要依赖的模块变得越来越多,这个时候,如何有效的组织这些模块就成了一个非常重要的问题。依赖注入解决的正是如何有效组织代码依赖模块的问题。你可能在一些框架或者库种听说过“依赖注入”这个词,比如说着名的前端框架AngularJS,依赖注入就是其中一个非常重要的特性。但是,依赖注入根本就不是什么新鲜玩意,它在其他的编程语言例如PHP中已经存在已久。同时,依赖注入也没有想象种那样复杂。在本文中,我们将一起来学习JavaScript中的依赖注入的概念,深入浅出的讲解如何编写“依赖注入风格”的代码。

packagecom.test.manager;publicclassMyManager{privatestaticMyManagerinstance;privateListStringdataList=newArrayList();privateMyManager{}publicstaticMyManagergetManager{if(instance==null){instance=newMyManager();}returninstance;}publicvoiddoSomething(){各种处理}publicvoidputData(Strings){对dataList的处理;}xxx其他对成员变量的操作方法等}

利用闭包的强大威力,但从表面上看,它们似乎与回调无关。下面一起来研究其中最强大的一个:模块。

一、目标设想我们有两个模块。第一个是负责Ajax请求服务,第二个是路由。复制代码 代码如下:var service = function() { return { name: 'Service' };}var router = function() { return { name: 'Router' };}我们有另一个函数需要用到这两个模块。复制代码 代码如下:var doSomething = function { var s = service;};为使看起来更有趣,这函数接受一个参数。当然,我们完全可以使用上面的代码,但这显然不够灵活。如果我们想使用ServiceXML或ServiceJSON呢,或者如果我们需要一些测试模块呢。我们不能仅靠编辑函数体来解决问题。首先,我们可以通过函数的参数来解决依赖性。即:复制代码 代码如下:var doSomething = function(service, router, other) { var s = service;};我们通过传递额外的参数来实现我们想要的功能,然而,这会带来新的问题。想象如果我们的doSomething 方法散落在我们的代码中。如果我们需要更改依赖条件,我们不可能更改所有调用函数的文件。

目标设定

现在我有个需求,要在项目B模块使用这个doSomething方法,但是AB两个模块不依赖,所以不能直接调用MyManager.getManager.doSomething()。想用反射实现,目前已经尝试过这种方法:

function foo() {
var something = "cool";
var another = [1, 2, 3];
function doSomething() {
console.log( something );
}
function doAnother() {
console.log( another.join( " ! " ) );
}
}

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

假设我们现在拥有两个模块。第一个模块的作用是发送Ajax请求,而第二个模块的作用则是用作路由。复制代码 代码如下:var service = function() { return { name: 'Service' };}var router = function() { return { name: 'Router' };}这时,我们编写了一个函数,它需要使用上面提到的两个模块:复制代码 代码如下:var doSomething = function { var s = service;};在这里,为了让我们的代码变得有趣一些,这个参数需要多接收几个参数。当然,我们完全可以使用上面的代码,但是无论从哪个方面来看上面的代码都略显得不那么灵活。要是我们需要使用的模块名称变为ServiceXML或者ServiceJSON该怎么办?或者说如果我们基于测试的目的想要去使用一些假的模块改怎么办。这时,我们不能仅仅去编辑函数本身。因此我们需要做的第一件事情就是将依赖的模块作为参数传递给函数,代码如下所示:复制代码 代码如下:var doSomething = function(service, router, other) { var s = service;};在上面的代码中,我们完全传递了我们所需要的模块。但是这又带来了一个新的问题。假设我们在代码的哥哥部分都调用了doSomething方法。这时,如果我们需要第三个依赖项该怎么办。这个时候,去编辑所有的函数调用代码并不是一个明智的方法。因此,我们需要一段代码来帮助我们做这件事情。这就是依赖注入器试图去解决的问题。现在我们可以来定下我们的目标了:

try{ Classclass1=Class.forName("com.test.manager.MyManager"); Constructor[]constructors=class1.getDeclaredConstructors(); AccessibleObject.setAccessible(constructors,true); for(Constructorcon:constructors){ if(con.isAccessible()){ ObjectclassObject=con.newInstance(); Methodmethod=class1.getMethod("doSomething"); method.invoke(classObject); } } } catch(Exceptione){ e.printStackTrace(); } }

正如在这段代码中所看到的,这里并没有明显的闭包,只有两个私有数据变量something和another,以及doSomething() 和doAnother() 两个内部函数,它们的词法作用域(而这就是闭包)也就是foo() 的内部作用域。

我们应该能够注册依赖关系1.注入应该接受一个函数,并返回一个我们需要的函数2.我们不能写太多东西——我们需要精简漂亮的语法3.注入应该保持被传递函数的作用域4.被传递的函数应该能够接受自定义参数,而不仅仅是依赖描述5.堪称完美的清单,下面 让我们实现它。三、RequireJS / AMD的方法你可能对RequireJS早有耳闻,它是解决依赖注入不错的选择。复制代码 代码如下:define(['service', 'router'], function { // ...});这种想法是先描述需要的依赖,然后再写你的函数。这里参数的顺序很重要。如上所说,让我们写一个叫做injector的模块,能接受相同的语法。复制代码 代码如下:var doSomething = injector.resolve(['service', 'router'], function(service, router, other) { expect.to.be; expect.to.be; expect;});doSomething;再继续之前我应该解释清楚doSomething函数体内容,我使用expect.js 仅是为了保证我写的代码的行为和我期望的是一样的,体现一点点TDD方法。下面开始我们的injector模块,这是非常棒的一个单例模式,所以它能在我们程序的不同部分工作的很好。复制代码 代码如下:var injector = { dependencies: {}, register: function { this.dependencies[key] = value; }, resolve: function {

1.我们应该能够去注册依赖项2.依赖注入器应该接收一个函数,然后返回一个能够获取所需资源的函数3.代码不应该复杂,而应该简单友好4.依赖注入器应该保持传递的函数作用域5.传递的函数应该能够接收自定义的参数,而不仅仅是被描述的依赖项

但是这种方法拿到的并不是那个单例对象,而是创建了一个新对象,这个新对象的dataList是空的。有没有可能通过反射的方式得到这个对象?要求是,得到的必须是这个单例对象,而且这个单例对象的dataList的值也是当前的值。

接下来看看下面的代码:

}}这是一个非常简单的对象,有两个方法,一个用来存储的属性。我们要做的是检查deps数组并在dependencies变量中搜索答案。剩下的只是调用.apply方法并传递之前的func方法的参数。复制代码 代码如下:resolve: function { var args = []; for(var i=0; i

requirejs/AMD方法

function CoolModule() {
var something = "cool";
var another = [1, 2, 3];
function doSomething() {
alert( something );
}
function doAnother() {
alert( another.join( " ! " ) );
}
return {
doSomething: doSomething,
doAnother: doAnother
};
}
var foo = CoolModule();
foo.doSomething(); // cool
foo.doAnother(); //1 ! 2 ! 3

四、反射方法根据维基百科的定义反射是指一个程序在运行时检查和修改一个对象的结构和行为的能力。简单的说,在JavaScript的上下文里,这具体指读取和分析的对象或函数的源代码。让我们完成文章开头提到的doSomething函数。如果你在控制台输出doSomething.tostring()。你将得到如下的字符串:复制代码 代码如下:"function (service, router, other) { var s = service;}"通过此方法返回的字符串给我们遍历参数的能力,更重要的是,能够获取他们的名字。这其实是Angular 实现它的依赖注入的方法。我偷了一点懒,直接截取Angular代码中获取参数的正则表达式。复制代码 代码如下:/^functions*[^/m我们可以像下面这样修改resolve 的代码:复制代码 代码如下:resolve: function() { var func, deps, scope, args = [], self = this; func = arguments[0]; deps = func.toString().match(/^functions*[^[1].replace; scope = arguments[1] || {}; return function() { var a = Array.prototype.slice.call; for(var i=0; i复制代码 代码如下:["function (service, router, other)", "service, router, other"]看起来,我们只需要第二项。一旦我们清楚空格并分割字符串就得到deps数组。只有一个大的改变:复制代码 代码如下:var a = Array.prototype.slice.call;...args.push(self.dependencies[d] && d != '' ? self.dependencies[d] : a.shift;我们循环遍历dependencies数组,如果发现缺失项则尝试从arguments对象中获取。谢天谢地,当数组为空时,shift方法只是返回undefined,而不是抛出一个错误。新版的injector 能像下面这样使用:复制代码 代码如下:var doSomething = injector.resolve(function(service, other, router) { expect.to.be; expect.to.be; expect;});doSomething;不必重写依赖并且他们的顺序可以打乱。它仍然有效,我们成功复制了Angular的魔法。

或许你已经听说过了大名鼎鼎的requirejs,它是一个能够很好的解决依赖注入问题的库:复制代码 代码如下:define(['service', 'router'], function { // ...});requirejs的思想是首先我们应该去描述所需要的模块,然后编写你自己的函数。其中,参数的顺序很重要。假设我们需要编写一个叫做injector的模块,它能够实现类似的语法。复制代码 代码如下:var doSomething = injector.resolve(['service', 'router'], function(service, router, other) { expect.to.be; expect.to.be; expect;});doSomething;在继续往下之前,需要说明的一点是在doSomething的函数体中我们使用了expect.js这个断言库来确保代码的正确性。这里有一点类似TDD的思想。

这个模式在JavaScript 中被称为模块。最常见的实现模块模式的方法通常被称为模块暴露,这里展示的是其变体。我们仔细研究一下这些代码。

然而,这种做法并不完美,这就是反射类型注射一个非常大的问题。压缩会破坏我们的逻辑,因为它改变参数的名字,我们将无法保持正确的映射关系。例如,doSometing()压缩后可能看起来像这样:复制代码 代码如下:var doSomething=function;var i=t()}Angular团队提出的解决方案看起来像:

现在我们正式开始编写我们的injector模块。首先它应该是一个单体,以便它能够在我们应用的各个部分都拥有同样的功能。复制代码 代码如下:var injector = { dependencies: {}, register: function { this.dependencies[key] = value; }, resolve: function {

首先,CoolModule() 只是一个函数,必须要通过调用它来创建一个模块实例。如果不执行外部函数,内部作用域和闭包都无法被创建。其次,CoolModule() 返回一个用对象字面量语法{ key: value, ... } 来表示的对象。这个返回的对象中含有对内部函数而不是内部数据变量的引用。我们保持内部数据变量是隐藏且私有的状态。可以将这个对象类型的返回值看作本质上是模块的公共API。这个对象类型的返回值最终被赋值给外部的变量foo,然后就可以通过它来访问API 中的属性方法,比如foo.doSomething()。

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

}}这个对象非常的简单,其中只包含两个函数以及一个用于存储目的的变量。我们需要做的事情是检查deps数组,然后在dependencies变量种寻找答案。剩余的部分,则是使用.apply方法去调用我们传递的func变量:复制代码 代码如下:resolve: function { var args = []; for(var i=0; i

从模块中返回一个实际的对象并不是必须的,也可以直接返回一个内部函数。jQuery 就是一个很好的例子。jQuery 和$ 标识符就是jQuery 模块的公共API,但它们本身都是函数(由于函数也是对象,它们本身也可以拥有属性)。

}]);这看起来很像我们开始时的解决方案。我没能找到一个更好的解决方案,所以决定结合这两种方法。下面是injector的最终版本。复制代码 代码如下:var injector = { dependencies: {}, register: function { 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; scope = arguments[2] || {}; } else { func = arguments[0]; deps = func.toString().match(/^functions*[^[1].replace; scope = arguments[1] || {}; } return function() { var a = Array.prototype.slice.call; for(var i=0; i复制代码 代码如下:var doSomething = injector.resolve('router,,service', function.name).to.be.to.be.name).to.be;doSomething;你可能注意到在第一个参数后面有两个逗号——注意这不是笔误。空值实际上代表“Other”参数。这显示了我们是如何控制参数顺序的。

如果你需要指定一个作用域,上面的代码也能够正常的运行。

doSomething() 和doAnother() 函数具有涵盖模块实例内部作用域的闭包( 通过调用CoolModule() 实现)。当通过返回一个含有属性引用的对象的方式来将函数传递到词法作用域外部时,我们已经创造了可以观察和实践闭包的条件。如果要更简单的描述,模块模式需要具备两个必要条件。

五、直接注入Scope有时我会用到第三个注入变量,它涉及到操作函数的作用域。所以,很多时候不需要使用这个变量。复制代码 代码如下:var injector = { dependencies: {}, register: function { this.dependencies[key] = value; }, resolve: function { var args = []; scope = scope || {}; for(var i=0; i复制代码 代码如下:var doSomething = injector.resolve(['service', 'router'], function { expect.to.be; expect.to.be; expect;});doSomething;六、结束语其实我们大部分人都用过依赖注入,只是我们没有意识到。即使你不知道这个术语,你可能在你的代码里用到它百万次了。希望这篇文章能加深你对它的了解。

在上面的代码中,Array.prototype.slice.call的作用是将arguments变量转换为一个真正的数组。到目前为止,我们的代码可以完美的通过测试。但是这里的问题是我们必须要将需要的模块写两次,而且不能够随意排列顺序。额外的参数总是排在所有的依赖项之后。

  1. 必须有外部的封闭函数,该函数必须至少被调用一次(每次调用都会创建一个新的模块实例)。

  2. 封闭函数必须返回至少一个内部函数,这样内部函数才能在私有作用域中形成闭包,并且可以访问或者修改私有的状态。

反射方法

一个具有函数属性的对象本身并不是真正的模块。从方便观察的角度看,一个从函数调用所返回的,只有数据属性而没有闭包函数的对象并不是真正的模块。上一个示例代码中有一个叫作CoolModule() 的独立的模块创建器,可以被调用任意多次,每次调用都会创建一个新的模块实例。当只需要一个实例时,可以对这个模式进行简单的改进来实现单例模式:

根据维基百科中的解释,反射指的是程序可以在运行过程中,一个对象可以修改自己的结构和行为。在JavaScript中,简单来说就是阅读一个对象的源码并且分析源码的能力。还是回到我们的doSomething方法,如果你调用doSomething.toString()方法,你可以获得下面的字符串:复制代码 代码如下:"function (service, router, other) { var s = service;}"这样一来,只要使用这个方法,我们就可以轻松的获取到我们想要的参数,以及更重要的一点就是他们的名字。这也是AngularJS实现依赖注入所使用的方法。在AngularJS的代码中,我们可以看到下面的正则表达式:复制代码 代码如下:/^functions*[^/m我们可以将resolve方法修改成如下所示的代码:

var foo = (function CoolModule() {
var something = "cool";
var another = [1, 2, 3];
function doSomething() {
alert( something );
}
function doAnother() {
alert( another.join( " ! " ) );
}
return {
doSomething: doSomething,
doAnother: doAnother
};
})();
foo.doSomething(); // cool
foo.doAnother(); // 1 ! 2 ! 3

复制代码 代码如下:resolve: function() { var func, deps, scope, args = [], self = this; func = arguments[0]; deps = func.toString().match(/^functions*[^[1].replace; scope = arguments[1] || {}; return function() { var a = Array.prototype.slice.call; for(var i=0; i

立即调用这个函数并将返回值直接赋值给单例的模块实例标识符foo。

我们使用上面的正则表达式去匹配我们定义的函数,我们可以获取到下面的结果:复制代码 代码如下:["function (service, router, other)", "service, router, other"]此时,我们只需要第二项。但是一旦我们去除了多余的空格并以,来切分字符串以后,我们就得到了deps数组。下面的代码就是我们进行修改的部分:复制代码 代码如下:var a = Array.prototype.slice.call;...args.push(self.dependencies[d] && d != '' ? self.dependencies[d] : a.shift;

模块也是普通的函数,因此可以接受参数:

在上面的代码中,我们遍历了依赖项目,如果其中有缺失的项目,如果依赖项目中有缺失的部分,我们就从arguments对象中获取。如果一个数组是空数组,那么使用shift方法将只会返回undefined,而不会抛出一个错误。到目前为止,新版本的injector看起来如下所示:复制代码 代码如下:var doSomething = injector.resolve(function(service, other, router) { expect.to.be; expect.to.be; expect;});doSomething;

function CoolModule(id) {
function identify() {
console.log( id );
}
return {
identify: identify
};
}
var foo1 = CoolModule( "foo 1" );
var foo2 = CoolModule( "foo 2" );
foo1.identify(); // "foo 1"
foo2.identify(); // "foo 2"

在上面的代码中,我们可以随意混淆依赖项的顺序。

模块模式另一个简单但强大的变化用法是,命名将要作为公共API 返回的对象:

但是,没有什么是完美的。反射方法的依赖注入存在一个非常严重的问题。当代码简化时,会发生错误。这是因为在代码简化的过程中,参数的名称发生了变化,这将导致依赖项无法解析。例如:复制代码 代码如下:var doSomething=function;var i=t()}因此我们需要下面的解决方案,就像AngularJS中那样:复制代码 代码如下:var doSomething = injector.resolve(['service', 'router', function {

var foo = (function CoolModule(id) {
function change() {
// 修改公共API
publicAPI.identify = identify2;
}
function identify1() {
alert( id );
}
function identify2() {
alert( id.toUpperCase() );
}
var publicAPI = {
change: change,
identify: identify1
};
return publicAPI;
})( "foo module" );
foo.identify(); // foo module
foo.change();
foo.identify(); // FOO MODULE

}]);这和最一开始看到的AMD的解决方案很类似,于是我们可以将上面两种方法整合起来,最终代码如下所示:复制代码 代码如下:var injector = { dependencies: {}, register: function { 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; scope = arguments[2] || {}; } else { func = arguments[0]; deps = func.toString().match(/^functions*[^[1].replace; scope = arguments[1] || {}; } return function() { var a = Array.prototype.slice.call; for(var i=0; i

通过在模块实例的内部保留对公共API 对象的内部引用,可以从内部对模块实例进行修改,包括添加或删除方法和属性,以及修改它们的值。

这一个版本的resolve方法可以接受两个或者三个参数。下面是一段测试代码:复制代码 代码如下:var doSomething = injector.resolve('router,,service', function.name).to.be.to.be.name).to.be;doSomething;你可能注意到了两个逗号之间什么都没有,这并不是错误。这个空缺是留给Other这个参数的。这就是我们控制参数顺序的方法。


结语

更多angular1/2/4、ionic1/2/3、react、vue、微信小程序、nodejs等技术文章、视频教程和开源项目,请关注微信公众号——全栈弄潮儿

在上面的内容中,我们介绍了几种JavaScript中依赖注入的方法,希望本文能够帮助你开始使用依赖注入这个技巧,并且写出依赖注入风格的代码。

图片 1

编辑:操作系统 本文来源:但是这种方法拿到的并不是那个单例对象,}我们

关键词:

  • 上一篇:没有了
  • 下一篇:没有了