从全局 function 到 ES6 的模块化体系

1 全局 function 模式

javascript

function m1() {
  // doSomething
}

function m2() {
  // doSomething
}

2 namespace 模式

javascript

var myModule = {
  data: "ZiJieYuan",
  foo() {
    console.log(`foo() ${this.data}`);
  },
  bar() {
    console.log(`bar() ${this.data}`);
  },
};
myModule.data = "能直接修改模块内部的数据";
myModule.foo();

3 IIFE

3.1 匿名函数自调用(闭包)

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

html

<!-- 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>

javascript

// module.js文件
(function (window) {
  let data = "www.zijieyuan.com";
  //操作数据的函数
  function foo() {
    //用于暴露有函数
    console.log(`foo() ${data}`);
  }
  function bar() {
    //用于暴露有函数
    console.log(`bar() ${data}`);
    otherFun(); //内部调用
  }
  function otherFun() {
    //内部私有的函数
    console.log("otherFun()");
  }
  //暴露行为
  window.myModule = { foo, bar }; //ES6写法
})(window);

3.2 IIFE 模式增强

html

<!-- 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>

javascript

// 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);

4 CommonJS 模块

4.1 概念

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

4.2 特点

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

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

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

javascript

// 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

4.4 模块的加载机制

CommonJS 模块的加载机制是，输入的是被输出的值的拷贝。也就是说，一旦输出一个值，模块内部的变化就影响不到这个值。这点与 ES6 模块化有重大差异（下文会介绍），请看下面这个例子：

javascript

// 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); // 3
incCounter();
console.log(counter); // 3 说明lib.js模块内部的变化就影响不到counter了

5 AMD (Asynchronous Module Definition)

5.1 概念

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

5.2 使用 require.js

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

6 CMD (Common Module Definition)

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

javascript

//定义没有依赖的模块
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();
});

6.1. AMD 与 CMD 区别

javascript

// CMD
define(function (requie, exports, module) {
  //依赖就近书写
  var module1 = require("Module1");
  var result1 = module1.exec();
  module.exports = {
    result1: result1,
  };
});

// AMD
define(["Module1"], function (module1) {
  var result1 = module1.exec();
  return {
    result1: result1,
  };
});

从上面的代码比较中我们可以得出 AMD 规范和 CMD 规范的区别

对依赖的处理：
- AMD 推崇依赖前置，即通过依赖数组的方式提前声明当前模块的依赖；
- CMD 推崇依赖就近，在编程需要用到的时候通过调用 require 方法动态引入；
在本模块的对外输出：
- AMD 推崇通过返回值的方式对外输出；
- CMD 推崇通过给 module.exports 赋值的方式对外输出；

7 ESM

7.1 概念

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

7.2 基本使用

javascript

// 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);
}

// 使用import命令的时候，用户需要知道所要加载的变量名或函数名，否则无法加载。为了给用户提供方便，让他们不用阅读文档就能加载模块，就要用到export default命令，为模块指定默认输出。
// export-default.js
export default function () {
  console.log("foo");
}

// import-default.js
import customName from "./export-default";
customName(); // 'foo'

ES6 模块与 CommonJS 模块的差异

CommonJS 模块输出的是一个值的拷贝，ES6 模块输出的是值的引用；
CommonJS 模块是运行时加载，ES6 模块是编译时输出接口；
第二个差异是因为 CommonJS 加载的是一个对象（即 module.exports 属性），该对象只有在脚本运行完才会生成。而 ES6 模块不是对象，它的对外接口只是一种静态定义，在代码静态解析阶段就会生成。

8 UMD (Universal Module Definition)

是一种 javascript 通用模块定义规范，让你的模块能在 javascript 所有运行环境中发挥作用。意味着要同时满足 CommonJS, AMD, CMD 的标准，以下为实现

javascript

(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模块",
  };
});

9 总结

9.1 模块化的好处

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

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

请求过多

首先我们要依赖多个模块，那样就会发送多个请求，导致请求过多；
依赖模糊
我们不知道他们的具体依赖关系是什么，也就是说很容易因为不了解他们之间的依赖关系导致加载先后顺序出错；
难以维护
以上两种原因就导致了很难维护，很可能出现牵一发而动全身的情况导致项目出现严重的问题。模块化固然有多个好处，然而一个页面需要引入多个 js 文件，就会出现以上这些问题。

9.3 总结

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

从全局 function 到 ES6 的模块化体系 ​

1 全局 function 模式 ​

2 namespace 模式 ​

3 IIFE ​

3.1 匿名函数自调用(闭包) ​

3.2 IIFE 模式增强 ​

4 CommonJS 模块 ​

4.1 概念 ​

4.2 特点 ​

4.4 模块的加载机制 ​

5 AMD (Asynchronous Module Definition) ​

5.1 概念 ​

5.2 使用 require.js ​

6 CMD (Common Module Definition) ​

6.1. AMD 与 CMD 区别 ​

7 ESM ​

7.1 概念 ​

7.2 基本使用 ​

8 UMD (Universal Module Definition) ​

9 总结 ​

9.1 模块化的好处 ​

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

9.3 总结 ​

从全局 function 到 ES6 的模块化体系

1 全局 function 模式

2 namespace 模式

3 IIFE

3.1 匿名函数自调用(闭包)

3.2 IIFE 模式增强

4 CommonJS 模块

4.1 概念

4.2 特点

4.4 模块的加载机制

5 AMD (Asynchronous Module Definition)

5.1 概念

5.2 使用 require.js

6 CMD (Common Module Definition)

6.1. AMD 与 CMD 区别

7 ESM

7.1 概念

7.2 基本使用

8 UMD (Universal Module Definition)

9 总结

9.1 模块化的好处

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

9.3 总结