Js中前端模块化的详细分析及其区别对比

追溯根源，来到Js模块化规范

1、CommonJS规范（同步加载模块）

// 导入
require("module");
require("../app.js");
// 导出
exports.getStoreInfo = function() {};
module.exports = someValue;

1. 同步加载方式不适合在浏览器环境中使用，同步意味着阻塞加载，浏览器资源是异步加载的

2. 不能非阻塞的并行加载多个模块

1. 简单容易使用

2. 服务器端模块便于复用

AMD（异步加载模块）

// 定义
define("module", ["dep1", "dep2"], function(d1, d2) {...});
// 加载模块
require(["module", "../app"], function(module, app) {...});

1. 适合在浏览器环境中异步加载模块

2. 可以并行加载多个模块

1. 提高了开发成本，代码的阅读和书写比较困难，模块定义方式的语义不顺畅

2. 不符合通用的模块化思维方式，是一种妥协的实现

1. require函数检查依赖的模块，根据配置文件，获取js文件的实际路径

2. 根据js文件实际路径，在dom中插入script节点，并绑定onload事件来获取该模块加载完成的通知。

3. 依赖script全部加载完成后，调用回调函数

CMD规范（异步加载模块）

1. require 是一个方法，接受模块标识作为唯一参数，用来获取其他模块提供的接口：require(id)

2. exports 是一个对象，用来向外提供模块接口

3. module 是一个对象，上面存储了与当前模块相关联的一些属性和方法

define(function(require, exports, module) {
 var a = require('./a');
 a.doSomething();
 // 依赖就近书写，什么时候用到什么时候引入
 var b = require('./b');
 b.doSomething();
});

1. 依赖就近，延迟执行

2. 可以很容易在 Node.js 中运行

1. 依赖 SPM 打包，模块的加载逻辑偏重

AMD 与 CMD 的区别

1. 对于依赖的模块，AMD 是提前执行，CMD 是延迟执行。不过 RequireJS 从2.0开始，也改成了可以延迟执行（根据写法不同，处理方式不同）。CMD 推崇 as lazy as possible.

2. AMD推崇依赖前置；CMD推崇依赖就近，只有在用到某个模块的时候再去require。

// AMD
define(['./a', './b'], function(a, b) { // 依赖必须一开始就写好 
 a.doSomething() 
 // 此处略去 100 行 
 b.doSomething() 
 ...
});
// CMD
define(function(require, exports, module) {
 var a = require('./a') 
 a.doSomething() 
 // 此处略去 100 行 
 var b = require('./b') 
 // 依赖可以就近书写 
 b.doSomething()
 // ... 
});

UMD

(function (window, factory) {
 if (typeof exports === 'object') {
 
 module.exports = factory();
 } else if (typeof define === 'function' && define.amd) {
 
 define(factory);
 } else {
 
 window.eventUtil = factory();
 }
})(this, function () {
 //module ...
});

ES6模块化

// 导入
import "/app";
import React from “react”;
import { Component } from “react”;
// 导出
export function multiply() {...};
export var year = 2018;
export default ...
...

1. 容易进行静态分析

2. 面向未来的 EcmaScript 标准

1. 原生浏览器端还没有实现该标准

2. 全新的命令字，新版的 Node.js才支持。

回到问题“require与import的区别”

1. 对于基本数据类型，属于复制。即会被模块缓存；同时，在另一个模块可以对该模块输出的变量重新赋值。

2. 对于复杂数据类型，属于浅拷贝。由于两个模块引用的对象指向同一个内存空间，因此对该模块的值做修改时会影响另一个模块。

3. 当使用require命令加载某个模块时，就会运行整个模块的代码。

4. 当使用require命令加载同一个模块时，不会再执行该模块，而是取到缓存之中的值。也就是说，CommonJS模块无论加载多少次，都只会在第一次加载时运行一次，以后再加载，就返回第一次运行的结果，除非手动清除系统缓存。

5. 循环加载时，属于加载时执行。即脚本代码在require的时候，就会全部执行。一旦出现某个模块被"循环加载"，就只输出已经执行的部分，还未执行的部分不会输出。

1. ES6模块中的值属于【动态只读引用】。

2. 对于只读来说，即不允许修改引入变量的值，import的变量是只读的，不论是基本数据类型还是复杂数据类型。当模块遇到import命令时，就会生成一个只读引用。等到脚本真正执行时，再根据这个只读引用，到被加载的那个模块里面去取值。

3. 对于动态来说，原始值发生变化，import加载的值也会发生变化。不论是基本数据类型还是复杂数据类型。

4. 循环加载时，ES6模块是动态引用。只要两个模块之间存在某个引用，代码就能够执行。