概念

由于代码之间会发生大量交互，如果结构不合理，这些代码就会变得难以维护、难以测试、难以调试。而使用模块化就解决了这些问题，模块化的特点如下：

可重用性：当应用被组织成模块时，可以方便的在其他地方重用这些模块，避免编写重复代码，从而加快开发流程；
可读性：当应用变得越来越复杂时，如果在一个文件中编写所有功能，代码会变得难以阅读。如果使用模块设计应用，每个功能都分布在各自的模块中，代码就会更加清晰、易读；
可维护性：软件的美妙之处在于进化，从长远来看，我们需要不断为应用增加新的功能。当应用被结构化为模块时，可以轻松添加或删除功能。除此之外，修复错误也是软件维护的一部分，使用模块就可以更快速地定位问题。

模块化是一种将系统分离成独立功能部分的方法，可以将系统分割成独立的功能部分，严格定义模块接口，模块间具有透明性。通过将代码进行模块化分隔，每个文件彼此独立，开发者更容易开发和维护代码，模块之间又能够互相调用和通信，这就是现代化开发的基本模式。

类型

全局function模式 : 将不同的功能封装成不同的全局函数

存在的问题：污染全局命名空间, 容易引起命名冲突或数据不安全，而且模块成员之间看不出直接关系

function m1(){
  //...
}
function m2(){
  //...
}

namespace模式（命名空间） : 简单对象封装

作用: 减少了全局变量，解决命名冲突

存在的问题: 数据不安全(外部可以直接修改模块内部的数据)，这样的写法会暴露所有模块成员，内部状态可以被外部改写

let myModule = {
  data: 'hello world',
  foo() {
    console.log(`foo() ${this.data}`)
  },
}
myModule.data = 'hello world everyone' //能直接修改模块内部的数据
myModule.foo() // foo() hello world everyon

IIFE模式：匿名函数自调用(闭包)

作用: 数据是私有的, 外部只能通过暴露的方法操作

编码: 将数据和行为封装到一个函数内部, 通过给window添加属性来向外暴露接口

存在的问题: 如果当前这个模块依赖另一个模块怎么办?

// module.js文件
(function(window) {
  let data = 'hello world'
  function foo() {
    console.log(`foo() ${data}`)
  }
  window.myModule = { foo, bar } //ES6写法
})(window)

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

引入依赖（现代模块实现的基石）

// module.js文件
(function(window, $) {
  let data = 'www.baidu.com'
  //操作数据的函数
  function foo() {
    //用于暴露有函数
    console.log(`foo() ${data}`)
    $('body').css('background', 'red')
  }
  //暴露行为
  window.myModule = { foo }
})(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>

问题

请求过多：首先我们要依赖多个模块，那样就会发送多个请求，导致请求过多
依赖模糊：我们不知道他们的具体依赖关系是什么，也就是说很容易因为不了解他们之间的依赖关系导致加载先后顺序出错。

以上两种原因就导致了很难维护，很可能出现牵一发而动全身的情况导致项目出现严重的问题。模块化固然有多个好处，然而一个页面需要引入多个js文件，就会出现以上这些问题。而这些问题可以通过模块化规范来解决，下面介绍开发中最流行的commonjs, AMD, ES6, CMD规范。

CommonJS

概述

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

特点

所有代码都运行在模块作用域，不会污染全局作用域；

模块可以多次加载，但是只会在第一次加载时运行一次，然后运行结果就被缓存了，以后再加载，就直接读取缓存结果（require缓存）。要想让模块再次运行，必须清除缓存；所有缓存的模块保存在require.cache之中
模块加载的顺序，按照其在代码中出现的顺序；
输入的是被输出的值的拷贝, 也就是说，一旦输出一个值，模块内部的变化就影响不到这个值。这点与ES6模块化有重大差异

基本语法

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

此处我们有个疑问：CommonJS暴露的模块到底是什么?

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

// example.js
var x = 5;
var addX = function (value) {
  return value + x;
};
module.exports.x = x;
module.exports.addX = addX;

// index.js
var example = require('./example.js');
console.log(example.x); // 5
console.log(example.addX(1)); // 6

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

模块的加载机制

// lib.js
var counter = 3;
function incCounter() {
  counter++;
}
module.exports = {
  counter: counter,
  incCounter: incCounter,
};

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

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

ChatGpt上的问答：

// lib.js
var counter = 3;
function incCounter() {
  counter++;
}
function getCounter() {
  return counter;
}
module.exports = {
  incCounter: incCounter,
  getCounter:getCounter
};

// main.js
var getCounter = require('./lib').getCounter;
var incCounter = require('./lib').incCounter;

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

源码查看

AMD

CommonJS规范加载模块是同步的，也就是说，只有加载完成，才能执行后面的操作。AMD规范则是非同步加载模块，允许指定回调函数。由于Node.js主要用于服务器编程，模块文件一般都已经存在于本地硬盘，所以加载起来比较快，不用考虑非同步加载的方式，所以CommonJS规范比较适用。但是，如果是浏览器环境，要从服务器端加载模块，这时就必须采用非同步模式，因此浏览器端一般采用AMD规范。此外AMD规范比CommonJS规范在浏览器端实现要来着早。

基本用法

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

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


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

RequireJS

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

官网: requirejs.org/

github: github.com/requirejs/r…

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

源码查看

CMD

CMD规范专门用于浏览器端，模块的加载是异步的，模块使用时才会加载执行。CMD规范整合了CommonJS和AMD规范的特点。在 Sea.js 中，所有 JavaScript 模块都遵循 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()
})

Sea.js

seajs.github.io/seajs/docs/…

github:github.com/seajs/seajs

AMD 和 CMD 的两个主要区别如下：

// AMD 依赖前置 依赖项须提前写好
define(['dataService'], function(dataService) {
  // dataService.doSomething()
  // ....
})


// CMD 依赖就近引入
define(function (require, exports, module) {
  	// 同步加载
 	var dataService = requier('./dataService)
    dataService.doSomething()
    // 异步加载
 	require.async('./module', function (m3) {
    	console.log('异步引入依赖模块  ' + m3.API_KEY)
  	})
})

AMD 需要异步加载模块，而 CMD 在加载模块时，可以同步加载（require），也可以异步加载（require.async）。
CMD 遵循依赖就近原则，AMD 遵循依赖前置原则。也就是说，在 AMD 中，需要把模块所需要的依赖都提前在依赖数组中声明。而在 CMD 中，只需要在具体代码逻辑内，使用依赖前，把依赖的模块 require 进来。

UMD

UMD 全程为 Universal Module Definition，即统一模块定义。其实 UMD 并不是一个模块管理规范，而是带有前后端同构思想的模块封装工具。

UMD 是一组同时支持 AMD 和 CommonJS 的模式，它旨在使代码无论执行代码的环境如何都能正常工作，通过 UMD 可以在合适的环境选择对应的模块规范。比如在 Node.js 环境中采用 CommonJS 模块管理，在浏览器环境且支持 AMD 的情况下采用 AMD 模块，否则导出为全局函数。

一个UMD模块由两部分组成：

立即调用函数表达式 (IIFE)：它会检查使用模块的环境。其有两个参数：root 和 factory。 root 是对全局范围的 this 引用，而 factory 是定义模块的函数。
匿名函数：创建模块，此匿名函数被传递任意数量的参数以指定模块的依赖关系。

(function(root, factory) {
    if (typeof module === 'object' && typeof module.exports === 'object') {
        console.log('是commonjs模块规范，nodejs环境')
        module.exports = factory();
    } else if (typeof define === 'function' && define.amd) {
        console.log('是AMD模块规范，如require.js')
        define(factory())
    } else if (typeof define === 'function' && define.cmd) {
        console.log('是CMD模块规范，如sea.js')
        define(function(require, exports, module) {
            module.exports = factory()
        })
    } else {
        console.log('没有模块环境，直接挂载在全局对象上')
        root.umdModule = factory();
    }
}(this, function() {
    return {
        name: '我是一个umd模块'
    }
}))

源码查看

ES6模块化

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

基本语法

/** 定义模块 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);
}

ES6-Babel-Browserify使用教程

# 1、创建package.json
npm init

# 2、安装babel-cli, babel-preset-es2015和browserify
 npm install babel-cli browserify -g
 npm install babel-preset-es2015 --save-dev
//preset 预设(将es6转换成es5的所有插件打包)

# 3、定义.babelrc文件
{
   "presets": ["es2015"]
}

# 4、定义模块代码 
## 新建modules文件夹并创建以下文件
### module1.js文件
// 分别暴露
export function foo() {
  console.log('foo() module1')
}
export function bar() {
  console.log('bar() module1')
}

### module2.js文件
// 统一暴露
function fun1() {
  console.log('fun1() module2')
}
function fun2() {
  console.log('fun2() module2')
}
export { fun1, fun2 }

### module3.js文件
// 默认暴露 可以暴露任意数据类项，暴露什么数据，接收到就是什么数据
export default () => {
  console.log('默认暴露')
}

### app.js文件
import { foo, bar } from './module1'
import { fun1, fun2 } from './module2'
import module3 from './module3'
foo()
bar()
fun1()
fun2()
module3()

# 5、编译并在index.html中引入

// 使用Babel将ES6编译为ES5代码(但包含CommonJS语法) 
babel modules -d dist

// 使用Browserify编译js 
browserify dist/app.js -o dist/bundle.js

// 在index.html文件中引入
<script type="text/javascript" src="dist/bundle.js"></script>

ES6模块与CommonJS 模块的差异

1、编译时加载和运行时加载

ES6 模块的设计思想是尽量的静态化，使得编译时就能确定模块的依赖关系，以及输入和输出的变量。所以ES6是编译时加载。CommonJS 和 AMD 模块，都只能在运行时确定这些东西。

// CommonJS模块  
let { stat, exists, readFile } = require('fs');  
// 等同于  
let _fs = require('fs');  
let stat = _fs.stat;  
let exists = _fs.exists;  
let readfile = _fs.readfile;
// -----------------
// ES6模块
import { stat, exists, readFile } from 'fs';

CommonJS 实质是整体加载fs模块（即加载fs的所有方法），生成一个对象（_fs），然后再从这个对象上面读取 3 个方法。这种加载称为“运行时加载”，因为只有运行时才能得到这个对象，导致完全没办法在编译时做“静态优化”。
ES6模块实质是从fs模块加载 3 个方法，其他方法不加载。这种加载称为“编译时加载 ”或者静态加载，即 ES6 可以在编译时就完成模块加载，效率要比 CommonJS 模块的加载方式高。

2、值拷贝和引用拷贝

前面提到了 CommonJS是值拷贝，模块加载完并输出一个值，模块内部的变化就影响不到这个值。因为这个值是一个原始类型的值，会被缓存。

ES6 模块的运行机制与 CommonJS 不一样。JS 引擎对脚本静态分析的时候，遇到模块加载命令import，就会生成一个只读引用。等到脚本真正执行时，再根据这个只读引用，到被加载的那个模块里面去取值。换句话说，ES6 的import有点像 Unix 系统的“符号连接”，原始值变了，import加载的值也会跟着变。因此，ES6 模块是动态引用，并且不会缓存值，模块里面的变量绑定其所在的模块。

模块介绍

概念

类型

全局function模式 : 将不同的功能封装成不同的全局函数

namespace模式（命名空间） : 简单对象封装

IIFE模式：匿名函数自调用(闭包)

CommonJS

概述

特点

基本语法

模块的加载机制

AMD

基本用法

RequireJS

CMD

基本用法

Sea.js

AMD 和 CMD 的两个主要区别如下：

UMD

ES6模块化

基本语法

ES6-Babel-Browserify使用教程

ES6模块与CommonJS 模块的差异

源码