详解 javascript 模块化加载方案进化史

一. 什么是模块化

将一些代码逻辑或者文件拆分，然后按照一定的规则进行组合，只是向外部暴露一些接口供用户使用。进而增加代码的可维护性。

二. 模块的演化过程

全局function模式

将不同的功能封装成不同的全局函数，

• 编码: 将不同的功能封装成不同的全局函数
• 问题: 污染全局命名空间, 容易引起命名冲突或数据不安全，而且模块成员之间看不出直接关系

function A(){

    // ....

}

function B(){

    // ....

}

namespace模式

简单对象封装

• 作用: 减少了全局变量，解决命名冲突
• 问题: 数据不安全(外部可以直接修改模块内部的数据)

let module = {
    data: 'hello, boer',
    foo() {
        // ...
    }

    bar() {
        // ...
    }
}



// 可以直接修改模块内部的数据

module.data = 'modify name'

module.foo()

三. IIFE模式

匿名函数自调用(闭包)

• 作用: 数据是私有的, 外部只能通过暴露的方法操作
• 编码: 将数据和行为封装到一个函数内部, 通过给window添加属性来向外暴露接口
• 问题: 如果当前这个模块依赖另一个模块怎么办?

// index.html文件 

<script type="text/javascript" src="module.js"></script> 
<script type="text/javascript"> 
    myModule.foo() 
    myModule.bar() 
    console.log(myModule.data) 
    
    //undefined 不能访问模块内部数据 
    myModule.data = 'xxxx' //不是修改的模块内部的data 
    myModule.foo() //没有改变 
</script>

(function(window){
    let data = 'hello,boer'

    //操作数据的函数
  function foo() {
  
    //用于暴露有函数
    console.log(`foo() ${data}`)
  }

  function bar() {
    //用于暴露有函数
    console.log(`bar() ${data}`)
    otherFun() //内部调用
  }

  function otherFun() {
    //内部私有的函数
    console.log('otherFun()')
  }

  //暴露行为

  window.myModule = { foo, bar } //ES6写法

})(window)

输出结果：

四. IIFE模式增强

引入依赖

// module.js文件 

(function(window, $) {
    let data = 'www.baidu.com' //操作数据的函数 
    
    function foo() { 
        //用于暴露有函数 
        console.log(`foo() ${data}`) 
        $('body').css('background', 'red') 
    } 

    function bar() {
         //用于暴露有函数 
         console.log(`bar() ${data}`) 
         otherFun() //内部调用 
    } 

    function otherFun() {
          //内部私有的函数 
          console.log('otherFun()') 

     } 

     //暴露行为 
     window.myModule = { foo, bar } 

})(window, jQuery)

 // index.html文件 <!-- 引入的js必须有一定顺序 --> 

 <script type="text/javascript" src="jquery-1.10.1.js"></script> 

 <script type="text/javascript" src="module.js"></script> 

 <script type="text/javascript"> 
     myModule.foo() 
 </script>

上例子通过jquery方法将页面的背景颜色改成红色，所以必须先引入jQuery库，就把这个库当作参数传入。这样做除了保证模块的独立性，还使得模块之间的依赖关系变得明显。

引入多个<script>后出现出现问题

• 请求过多

首先我们要依赖多个模块，那样就会发送多个请求，导致请求过多

• 依赖模糊

我们不知道他们的具体依赖关系是什么，也就是说很容易因为不了解他们之间的依赖关系导致加载先后顺序出错。

• 难以维护

以上两种原因就导致了很难维护，很可能出现牵一发而动全身的情况导致项目出现严重的问题。

模块化固然有多个好处，然而一个页面需要引入多个js文件，就会出现以上这些问题

五. 模块化的好处

• 避免命名冲突(减少命名空间污染)
• 更好的分离, 按需加载
• 更高复用性
• 高可维护性

六. Common.js

Node 应用由模块组成，采用 CommonJS 模块规范。每个文件就是一个模块，有自己的作用域。在一个文件里面定义的变量、函数、类，都是私有的，对其他文件不可见。

在服务器端，模块的加载是运行时同步加载的；在浏览器端，模块需要提前编译打包处理。

特点

• 所有代码都运行在模块作用域，不会污染全局作用域。
• 模块可以多次加载，但是只会在第一次加载时运行一次，然后运行结果就被缓存了，以后再加载，就直接读取缓存结果。要想让模块再次运行，必须清除缓存。
• 模块加载的顺序，按照其在代码中出现的顺序。

基本语法

暴露模块：

module.exports = value

// 或

exports.xxx = value

引入模块：

// 如果是第三方模块，xxx为模块名；如果是自定义模块，xxx为模块文件路径

const xx = require(xxx)

CommonJS规范规定，每个模块内部，module变量代表当前模块。这个变量是一个对象，它的exports属性（即module.exports）是对外的接口。

加载某个模块，其实是加载该模块的module.exports属性。

let x = 5

let add = function(value){
    return value + x
}


module.export.x = x

module.export.add = add

通过module.exports输出变量x和函数add。

//如果参数字符串以"./"开头，则表示加载的是一个位于相对路径

let example = require('./example.js')



console.log(example.x)

console.log(example.add(1)) // 6

require命令用于加载模块文件。require命令的基本功能是，读入并执行一个JavaScript文件，然后返回该模块的exports对象。如果没有发现指定模块，会报错。

为了方便，Node为每个模块提供一个exports变量，指向module.exports。这等同在每个模块头部，有一行这样的命令：

var exports = module.exports;

模块的加载机制

CommonJS模块的加载机制是，输入的是被输出的值的拷贝。也就是说，一旦输出一个值，模块内部的变化就影响不到这个值。

// lib.js 

let counter = 3; 
function incCounter() {
    counter++; 
} 

module.exports = {
    counter: counter, 
    incCounter: incCounter, 
};

输出内部变量counter和改写这个变量的内部方法incCounter。

// main.js 

var counter = require('./lib').counter; 
var incCounter = require('./lib').incCounter; 

console.log(counter); // 3 
incCounter(); 
console.log(counter); // 3

counter输出以后，lib.js模块内部的变化就影响不到counter了。

这是因为counter是一个原始类型的值，会被缓存。除非写成一个函数，才能得到内部变动后的值。

七. AMD

AMD规范则是非同步加载模块，允许指定回调函数。由于Node.js主要用于服务器编程，模块文件一般都已经存在于本地硬盘，所以加载起来比较快，不用考虑非同步加载的方式，所以CommonJS规范比较适用。但是，

如果是浏览器环境，要从服务器端加载模块，这时就必须采用非同步模式，因此浏览器端一般采用AMD规范。此外AMD规范比CommonJS规范在浏览器端实现要来着早。

定义暴露模块

//定义没有依赖的模块 

define(function(){
 return 模块 
})

//定义有依赖的模块 

define(['module1', 'module2'], function(m1, m2){
 return 模块 
})

引入使用模块:

require(['module1', 'module2'], function(m1, m2){
 使用m1/m2 
})

缺点：

• 使用相对复杂
• 模块js文件请求频繁

九. CMD

定义暴露模块：

//定义没有依赖的模块 
define(function(require, exports, module){
 exports.xxx = value 
 module.exports = value 
})

//定义有依赖的模块 
define(function(require, exports, module){
 //引入依赖模块(同步) 
 var module2 = require('./module2')
  //引入依赖模块(异步) 
 require.async('./module3', function (m3) {
 }) 

 //暴露模块 
 exports.xxx = value 

})

引入使用模块：

define(function (require) {
 var m1 = require('./module1') 
 var m4 = require('./module4') 
 m1.show() 
 m4.show() 
})

八. Es Module（ES6 模块化）

ES6 模块的设计思想是尽量的静态化，使得编译时就能确定模块的依赖关系，以及输入和输出的变量。CommonJS 和 AMD 模块，都只能在运行时确定这些东西。比如，CommonJS 模块就是对象，输入时必须查找对象属性。

语法

export命令用于规定模块的对外接口，import命令用于输入其他模块提供的功能。

• 导出

let name = 'foo name'

function hello(){
    console.log('hello')
}

class Person{}


// 方式一

export {
    name,
    // 导出改名
    hello as fooHellow
}

export {
    Person
}


// 方式二

export default name

• 导入

// 方式一

import fooName from './module.js'


// 方式二

// 导入改名

import { name as fooName } from './module.js'


// 方式三

// 全部引入

import * as mod from './module.js'


// 方式四

// 只加载，不引入

import {} from './module'


// 方法五

// 动态引入

import('./module.js').then(function(module){
    console.log(module)
})


// 方式六

// 同时引入默认成员与具名成员

import title, { name, age } from './module.js'


//方式七

//直接进行导入导出

export { foo, bar } from './module.js'

使用export default导出的文件也可是使用 default as XX 的方式进行导入

注意

• export的导出与导入方式并不是对象，而是固定的写法
• 模块的引入采用的是引用的方式，当值改变，使用值的地方也会改变
• 导入的模块的值是只读的，不可修改
• 引入的import只能放在文件的最顶层

九. ES6 模块与 CommonJS 模块的差异

1. CommonJS 模块输出的是一个值的拷贝，ES6 模块输出的是值的引用。
2. CommonJS 模块是运行时加载，ES6 模块是编译时输出接口。（ES6 模块只能写在开头，而CommonJS模块可以写在任何地方）

// lib.js 
export let counter = 3; 

export function incCounter() {
 counter++; 
} 

// main.js 

import { counter, incCounter } from './lib'; 

console.log(counter); // 3 
incCounter(); 

console.log(counter); // 4

ES6 模块的运行机制与 CommonJS 不一样。

ES6 模块是动态引用，并且不会缓存值，模块里面的变量绑定其所在的模块。

十. 总结

• CommonJS规范主要用于服务端编程，加载模块是同步的，这并不适合在浏览器环境，因为同步意味着阻塞加载，浏览器资源是异步加载的，因此有了AMD CMD解决方案。
• AMD规范在浏览器环境中异步加载模块，而且可以并行加载多个模块。不过，AMD规范开发成本高，代码的阅读和书写比较困难，模块定义方式的语义不顺畅。
• CMD规范与AMD规范很相似，都用于浏览器编程，依赖就近，延迟执行，可以很容易在Node.js中运行。不过，依赖SPM 打包，模块的加载逻辑偏重
• ES6 在语言标准的层面上，实现了模块功能，而且实现得相当简单，完全可以取代 CommonJS 和 AMD 规范，成为浏览器和服务器通用的模块解决方案。