标签：
这是一篇关于js模块化历程的长长的流水账，记录js模块化思想的诞生与变迁，展望ES6模块化标准的未来。经历过这段历史的人或许会感到沧桑，没经历过的人也应该知道这段历史。
在ajax还未提出之前，js还只是一种“玩具语言”，由Brendan Eich花了不到十天时间发明，用来在网页上进行表单校验、实现简单的动画效果等等，你可以回想一下那个网页上到处有公告块飘来飘去的时代。
这个时候并没有前端工程师，服务端工程师只需在页面上随便写写js就能搞定需求。那个时候的前端代码大概像这样：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
if(xx){
//.......
}
else{
//xxxxxxxxxxx
}
for(var i=0; i<10; i++){
//........
}
element.onclick = function(){
//.......
}
|
|
1
2
|
<script type="text/javascript" src="a.js"></script>
<script type="text/javascript" src="b.js"></script>
|
|
1
2
3
4
5
6
7
8
9
10
11
|
modA = function(){
var a,b; //变量a、b外部不可见
return {
add : function(c){
a + b + c;
},
format: function(){
//......
}
}
}()
|
|
1
2
3
|
app.util.modA = xxx;
app.tools.modA = xxx;
app.tools.modA.format = xxx;
|
|
1
|
app.tools.modA.format();
|
|
1
2
3
4
5
|
(function(window){
//代码
window.jQuery = window.$ = jQuery;//通过给window添加属性而暴漏到全局
})(window);
|
1. 模块的标识应遵循的规则（书写规范）2. 定义全局函数require，通过传入模块标识来引入其他模块，执行的结果即为别的模块暴漏出来的API3. 如果被require函数引入的模块中也包含依赖，那么依次加载这些依赖4. 如果引入模块失败，那么require函数应该报一个异常5. 模块通过变量exports来向往暴漏API，exports只能是一个对象，暴漏的API须作为此对象的属性。
|
1
2
3
4
5
6
7
8
|
//math.js
exports.add = function() {
var sum = 0, i = 0, args = arguments, l = args.length;
while (i < l) {
sum += args[i++];
}
return sum;
};
|
|
1
2
3
4
5
|
//increment.js
var add = require(‘math‘).add;
exports.increment = function(val) {
return add(val, 1);
};
|
|
1
2
3
4
|
//program.js
var inc = require(‘increment‘).increment;
var a = 1;
inc(a); // 2
|
1. 全局有一个module变量，用来定义模块2. 通过module.declare方法来定义一个模块3. module.declare方法只接收一个参数，那就是模块的factory，次factory可以是函数也可以是对象，如果是对象，那么模块输出就是此对象。4. 模块的factory函数传入三个参数：require,exports,module，用来引入其他依赖和导出本模块API5. 如果factory函数最后明确写有return数据（js函数中不写return默认返回undefined），那么return的内容即为模块的输出。
|
1
2
3
4
5
|
//可以使用exprots来对外暴漏API
module.declare(function(require, exports, module)
{
exports.foo = "bar";
});
|
|
1
2
3
4
5
|
//也可以直接return来对外暴漏数据
module.declare(function(require)
{
return { foo: "bar" };
});
|
1. 用全局函数define来定义模块，用法为：define(id?, dependencies?, factory);2. id为模块标识，遵从CommonJS Module Identifiers规范3. dependencies为依赖的模块数组，在factory中需传入形参与之一一对应4. 如果dependencies的值中有”require”、”exports”或”module”，则与commonjs中的实现保持一致5. 如果dependencies省略不写，则默认为[“require”, “exports”, “module”]，factory中也会默认传入require,exports,module6. 如果factory为函数，模块对外暴漏API的方法有三种：return任意类型的数据、exports.xxx=xxx、module.exports=xxx7. 如果factory为对象，则该对象即为模块的返回值
|
1
2
3
4
5
6
7
8
9
|
//a.js
define(function(){
console.log(‘a.js执行‘);
return {
hello: function(){
console.log(‘hello, a.js‘);
}
}
});
|
|
1
2
3
4
5
6
7
8
9
|
//b.js
define(function(){
console.log(‘b.js执行‘);
return {
hello: function(){
console.log(‘hello, b.js‘);
}
}
});
|
|
1
2
3
4
5
6
7
8
|
//main.js
require([‘a‘, ‘b‘], function(a, b){
console.log(‘main.js执行‘);
a.hello();
$(‘#b‘).click(function(){
b.hello();
});
})
|
|
1
|
hello, b.js
|
|
1
|
define([‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘, ‘f‘, ‘g‘], function(a, b, c, d, e, f, g){ ..... })
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
define(function(){
console.log(‘main2.js执行‘);
require([‘a‘], function(a){
a.hello();
});
$(‘#b‘).click(function(){
require([‘b‘], function(b){
b.hello();
});
});
});
|
|
1
2
3
4
5
6
7
|
var a = require(‘a‘);
a.hello();
$(‘#b‘).click(function(){
var b = require(‘b‘);
b.hello();
});
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
//d.js
define(function(require, exports, module){
console.log(‘d.js执行‘);
return {
helloA: function(){
var a = require(‘a‘);
a.hello();
},
run: function(){
$(‘#b‘).click(function(){
var b = require(‘b‘);
b.hello();
});
}
}
});
|
|
1
2
3
|
require([‘d‘], function(d){
});
|
|
1
2
3
4
5
6
7
8
9
|
//a.js
define(function(require, exports, module){
console.log(‘a.js执行‘);
return {
hello: function(){
console.log(‘hello, a.js‘);
}
}
});
|
|
1
2
3
4
5
6
7
8
9
|
//b.js
define(function(require, exports, module){
console.log(‘b.js执行‘);
return {
hello: function(){
console.log(‘hello, b.js‘);
}
}
});
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
//main.js
define(function(require, exports, module){
console.log(‘main.js执行‘);
var a = require(‘a‘);
a.hello();
$(‘#b‘).click(function(){
var b = require(‘b‘);
b.hello();
});
});
|
|
1
2
|
var b = require.async(‘b‘);
b.hello();
|
|
1
2
3
4
|
//方式一, a.js
export var a = 1;
export var obj = {name: ‘abc‘, age: 20};
export function run(){....}
|
|
1
2
3
4
5
|
//方式二, b.js
var a = 1;
var obj = {name: ‘abc‘, age: 20};
function run(){....}
export {a, obj, run}
|
|
1
2
|
import {run as go} from ‘a‘
run()
|
|
1
2
3
|
module foo from ‘a‘
console.log(foo.obj);
a.run();
|
标签：
原文地址：http://www.cnblogs.com/wyaocn/p/5761523.html
