利用了闭包的模块:
简单模块例子:
function fn(){ var x = 1; function y(){ console.log(x); } return { y:y} }
var do1 = fn()
do1.y(); // 1
我们可以将这个“对象类型”的返回值看做是 模块的公共API
这个例子中返回的实例中 y() 等于是拥有了函数fn的内部作用域的闭包。
模块模式条件(书):
1.必须由外部的封闭函数,且被调用。
2.封闭函数必须返回至少一个内部函数。
单例模式(平时使用的比较多):
var single = (function(){ var x = 1; function fn(){ console.log(1); }; return { fn:fn } })(); single.fn();//1
将模块函数使用IIFE 表达出来,因为是立即调用,所以此实例的标识foo为单例。?
还有一种在初始化html的时候使用的也比较多,如下:
(function(){ var u = {}; u.x = function(a){ console.log(a); } window.$custom = u; })(); $custom.x(1);//1
使用IIFE 立即给window动态增加一个属性,$custom,因为window的变量和方法是可以隐去的,我们可以直接调用$custom实例引用的方法x,最终打印1。
动态修改(返回实例引用中fn与fn2都用于内部作用的闭包,所以可以在外部通过调用fn2,动态修改内部id的值):
var foo = (function(){ var id = "hhh"; function fn(){ console.log(id); } function fn2(){ id = "MM" } return { fn:fn ,fn2:fn2 } })(); foo.fn();//hh foo.fn2(); foo.fn();//MM
当然了,你可以更改函数或者增加新的实例方法(之前的文章中有写 JS 创建自定义对象的方式方法)
再来一个(引用书中的例子):
var foo = (function x(){ var module = {}; function def(name,arr,impl){ for(let i = 0;i<arr.length;i++){ // 重新定义数组中的对象 arr[i] = module[arr[i]]; } module[name] = impl.apply(impl,arr); } function get(n){ return module[n]; } return {def:def,get:get} })()
定义一个先:
// 返回一个模块对象实例 foo.def('test',[],function(){
function h(n){return '我是test内部的h函数'+n} return { h : h }; }); foo.get('test').h('hi'); // 我是test内部的h函数hi // 返回方法函数本身 foo.def('test',[],function(){ function h(n){return '我是test内部的h函数'+n} return { h : h }; }); foo.get('test')('hi'); // 我是test内部的h函数hi
两种方式,第一种内部module的get 返回一个对象实例,含有h内部函数,可以调用;
第二种返回h函数本身,通过 '()' 直接调用即可。
再来一个,多重调用(在上面给module定义了test后,再来一个并且利用回调函数调用test)
foo.def('test2',['test'],function(callback){ function j(){ console.log(callback.h('hihihihi')+'其实我是test2'); } return { j:j } });
foo.get('test2').j();//我是test内部的h函数hihihihi其实我是test2
我们来分析一下,在foo.def 方法中核心的时候这句 apply(有关apply 、call和blind方面以后再表),简单说一下,apply方法把作用域第一个参数的作用域绑定或追加到调用的对象中,从何绑定this,并执行改方法,第二个参数就是执行这个方法需要的参数。
那么我们在调用def时,就是给foo中的内部对象module增加了一对键值对,module.name = impl() 这里得到impl函数执行后返回值
在调用get的时候,得到这个值,在第一个def中是test返回是 {h:h} 对象实例(调用foo.get()),所以我们使用 foo.get('test').h() 就调用了返回实例中的h函数,而h函数拥有访问h所在的作用域的闭包。
再来看第二个def,test2:
第二个def时我们给到3个参数,test,[test2]和一个匿名函数
foo在执行def方法时,首先循环数组,并重新对数组中的值进行重新赋值,这个例子中是 module[test],等于是得到了def1中的{h:h} 对象实例,然后调用apply方法,执行定义的匿名函数,返回值为 {j:j}
并且j方法中的callback 其实就是{h,h} ,(是这样的 module[test2] = impl.apply(impl,{h:h}) ),明白没?
所以foo中的内部对象 module又获得了一对简直,module.test2 = { j:j } ,并且j中的callback 是 {h:h}
最后我们通过 foo.get('test2') 获得了{j:j} 然后执行 j() 方法,并成功打印 “我是test内部的h函数hihihihi其实我是test2”。
此处在test2中,j()方法拥有作用域的闭包,也就是说可以访问到callback,而callback实际上在此事{h:h},而h也拥有其作用域的闭包。
可以说,这就是一种模块的表现方式或者说闭包的应用。
关于es6对模块有了重新的定义,再次我简单记录一下:
// test.js function h(){ return 'ggggg' } export h; // test2.js import h from 'test'; function j(){ console.log( h(); ) } export j; // foo.js module test from 'test'; module test2 from 'test2'; console.log( test2.h(); ) test2.j();
关键字:
import: 将一个模块的一个或者多个API 导入到当前作用域
export: 将当前的一个标识符导出为API
module: 将模块的API 导入并绑定到一个变量。