# 模块化机制

# 模块化理解

# 什么是模块化

# 模块化进化过程

全局 function 模式：将不同功能封装成不同的全局函数
namespace 模式：简单对象封装
IIFE 模式：匿名函数自调用（闭包）
IIFE 模式增强：引入依赖

# 模块化好处

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

# 引入多个 script 标签后出现的问题

请求过多
依赖模糊
难以维护

# 模块化规范

# CommonJS

CommonJS规范加载模块是同步的，也就是说，只有加载完成，才能执行后面的操作。

# 概述

Node 应用由模块组成，采用 CommonJS 模块规范。
每个文件就是一个模块，有自己的作用域。
在一个文件里面定义的变量、函数、类，都是私有的，对其他文件不可见。
在服务器端，模块的加载是运行时同步加载的；在浏览器端，模块需要提前编译打包处理。

# 特点

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

# 基本语法

暴露模块：module.exports = value或exports.xxx = value
引入模块：require(xxx)，如果是第三方模块，xxx为模块名；如果是自定义模块，xxx为模块文件路径

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

Q: CommonJS 暴露的模块到底是什么?

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

# 加载机制

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

# AMD

AMD规范则是非同步加载模块，允许指定回调函数。

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

# 基本语法

定义暴露模块:

//定义没有依赖的模块
define(function(){
   return 模块
})

1
2
3
4

//定义有依赖的模块
define(['module1', 'module2'], function(m1, m2){
  return 模块
})

1
2
3
4

引入使用模块:

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

1
2
3

# 未使用 AMD 规范与使用 require.js

通过比较两者的实现方法，来说明使用AMD规范的好处。

未使用AMD规范

// dataService.js文件
(function (window) {
  let msg = 'www.baidu.com'
  function getMsg() {
    return msg.toUpperCase()
  }
  window.dataService = {getMsg}
})(window)

1
2
3
4
5
6
7
8

// alerter.js文件
(function (window, dataService) {
  let name = 'Tom'
  function showMsg() {
    alert(dataService.getMsg() + ', ' + name)
  }
  window.alerter = {showMsg}
})(window, dataService)

1
2
3
4
5
6
7
8

// main.js文件
(function (alerter) {
  alerter.showMsg()
})(alerter)

1
2
3
4

// index.html文件
<div><h1>Modular Demo 1: 未使用AMD(require.js)</h1></div>
<script type="text/javascript" src="js/modules/dataService.js"></script>
<script type="text/javascript" src="js/modules/alerter.js"></script>
<script type="text/javascript" src="js/main.js"></script>

1
2
3
4
5

缺点：首先会发送多个请求，其次引入的js文件顺序不能搞错，否则会报错！

使用 require.js

RequireJS 是一个工具库，主要用于客户端的模块管理。它的模块管理遵守 AMD 规范，RequireJS 的基本思想是，通过 define 方法，将代码定义为模块；通过 require 方法，实现代码的模块加载。

小结：通过两者的比较，可以得出AMD模块定义的方法非常清晰，不会污染全局环境，能够清楚地显示依赖关系。AMD模式可以用于浏览器环境，并且允许非同步加载模块，也可以根据需要动态加载模块。

# CMD

CMD规范专门用于浏览器端，模块的加载是异步的，模块使用时才会加载执行。CMD规范整合了CommonJS和AMD规范的特点。在 Sea.js 中，所有 JavaScript 模块都遵循 CMD模块定义规范。

# 基本语法

定义暴露模块：

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

1
2
3
4
5

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

1
2
3
4
5
6
7
8
9
10

引入使用模块：

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

1
2
3
4
5
6

# ES6 模块化

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

# 基本语法

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

/** 定义模块 math.js **/
var basicNum = 0;
var add = function (a, b) {
    return a + b;
};
export { basicNum, add };
/** 引用模块 **/
import { basicNum, add } from './math';
function test(ele) {
    ele.textContent = add(99 + basicNum);
}

1
2
3
4
5
6
7
8
9
10
11

// export-default.js
export default function () {
  console.log('foo');
}
// import-default.js
import customName from './export-default';
customName(); // 'foo'

1
2
3
4
5
6
7

# ES6 模块与 CommonJS 模块的差异

CommonJS 模块输出的是一个值的拷贝，ES6 模块输出的是值的引用。
CommonJS 模块是运行时加载，ES6 模块是编译时输出接口。

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

# ES6-Babel-Browserify 使用教程

使用Babel将ES6编译为ES5代码，使用Browserify编译打包js。

# 总结

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

← 性能优化 - 渲染合成层 Tree-Sharking →