前端模块化(CommonJS、AMD、CMD、ES6模块化区别)

快来打我* 2022-11-14 15:59 568阅读 0赞

### 文章目录 ###

*  一、模块化的理解
 *   *  1.什么是模块?
     *  2.模块化的进化过程
     *   *  2.1全局function模式 : 将不同的功能封装成不同的全局函数
         *  2.2namespace模式 : 简单对象封装
         *  2.3IIFE模式：匿名函数自调用(闭包)
         *  2.4IIFE模式增强 : 引入依赖
     *  3.模块化的好处
     *  4.引入多个script后出现出现问题
 *  二、模块化规范
 *   *  1.CommonJS
     *   *  1.1基本语法
         *  1.2模块的加载机制
     *  2.AMD
     *   *  2.1基本语法
         *  2.2模块的加载机制
     *  3.CMD
     *   *  3.1基本语法
         *  3.2模块的加载机制
     *  4.ES6模块化
     *   *  4.1基本语法
         *  4.2模块的加载机制
         *  4.3ES6 模块与 CommonJS 模块的差异
 *  三、总结

随着前端代码日益膨胀，此时在JS方面就会考虑使用模块化规范去管理。 本文内容主要有理解模块化，为什么要模块化，模块化的优缺点以及模块化规范,并且介绍下开发中最流行的CommonJS, AMD, ES6、CMD规范。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5OTAzNTY3_size_16_color_FFFFFF_t_70]

# 一、模块化的理解 #

## 1.什么是模块? ##

*  将一个复杂的程序依据一定的规则(规范)封装成几个块(文件), 并进行组合在一起
 *  块的内部数据与实现是私有的, 只是向外部暴露一些接口(方法)与外部其它模块通信

## 2.模块化的进化过程 ##

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

**编码:** 将不同的功能封装成不同的全局函数

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

### 2.2namespace模式 : 简单对象封装 ###

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

let myModule = {
      data: 'www.baidu.com',
      foo() {
        console.log(`foo() ${this.data}`)
      },
      bar() {
        console.log(`bar() ${this.data}`)
      }
    }
    myModule.data = 'other data' //能直接修改模块内部的数据
    myModule.foo() // foo() other data

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

[闭包相关文章][Link 1]

**作用**: 数据是私有的, 外部只能通过暴露的方法操作  
**编码**: 将数据和行为封装到一个函数内部, 通过给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>

// module.js文件
    (function(window) {
      let data = 'www.baidu.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)

### 2.4IIFE模式增强 : 引入依赖 ###

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

## 3.模块化的好处 ##

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

## 4.引入多个script后出现出现问题 ##

1.  请求过多

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

1.  依赖模糊

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

1.  难以维护

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

# 二、模块化规范 #

## 1.CommonJS ##

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

**特点**：

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

### 1.1基本语法 ###

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

每个模块内部，**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;

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

var example = require('./example.js');//如果参数字符串以“./”开头，则表示加载的是一个位于相对路径
    console.log(example.x); // 5
    console.log(example.addX(1)); // 6

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

### 1.2模块的加载机制 ###

*  CommonJS 用于 node 端，是同步加载的，也就是说，只有加载完成，才能执行后面的操作。
 *  CommonJS模块的加载机制是，输入的是被输出的值的拷贝。也就是说，一旦输出一个值，模块内部的变化就影响不到这个值。  
    这点与ES6模块化有重大差异（ES6 模块输出的是值的引用）

## 2.AMD ##

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

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

### 2.1基本语法 ###

定义暴露模块:

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

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

引入使用模块:

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

### 2.2模块的加载机制 ###

AMD 依赖于 requirejs,是异步加载的，是提前加载，立即加载

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

## 3.CMD ##

CMD规范专门用于浏览器端，**模块的加载是异步的，模块使用时才会加载执行**。  
CMD规范整合了CommonJS和AMD规范的特点。

### 3.1基本语法 ###

定义暴露模块:

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

### 3.2模块的加载机制 ###

CMD 依赖于 seajs ,是异步加载，延后加载，就近加载，用时加载

**模块的加载是异步的，模块使用时才会加载执行**。

## 4.ES6模块化 ##

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

### 4.1基本语法 ###

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命令可以为该匿名函数指定任意名字。

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

### 4.2模块的加载机制 ###

*  模块支持异步加载
 *  同一个模块如果加载多次，将只执行一次。

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

默认情况下，浏览器同步加载JavaScript脚本，即渲染引擎遇到script标签就会停下来，等到脚本执行完毕再继续向下渲染。如果是外部脚本，还必须加入脚本下载的时间。

如果脚本体积很大，下载和执行的时间就会很长，因此造成浏览器堵塞，用户会感觉到浏览器“卡死”了，没有任何响应。这显然是很不好的体验，所以浏览器允许脚本异步加载，下面就是两种异步加载的语法。

上面的代码中，script标签打开defer或async属性，脚本就会异步加载。渲染引擎遇到这一行命令就会开始下载外部脚本，但不会等它下载和执行，而是直接执行后面的命令。

**defer**：等到整个页面正常渲染结束才会执行，  
**async**：一旦下载完成，渲染引擎就会中断渲染，执行这个脚本以后再继续渲染。  
如果有多个defer脚本，则会按照它们在页面出现的顺序加载，而多个async脚本是不能保证加载顺序的。

浏览器加载ES6模块时也使用script标签，但是要加入type=”module”属性。

上面的代码在网页中插入了一个模块foo.js，由于type属性设为module，所以浏览器知道这是一个ES6模块。

对于带有type=”module”的script，浏览器都是**异步加载的，不会造成浏览器堵塞，即等到整个页面渲染完再执行模块脚本**，等同于打开了script标签的defer属性。

script标签的async属性也可以打开，这时只要加载完成，渲染引擎就会中断渲染立即执行。执行完成后，再恢复渲染。

ES6模块也允许内嵌在网页中，语法行为与加载外部脚本完全一致。

**同一个模块如果加载多次，将只执行一次。**

### 4.3ES6 模块与 CommonJS 模块的差异 ###

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

因为CommonJS加载的是一个对象（即module.exports属性），该对象只有在脚本运行结束时才会生成。而ES6模块不是对象，它的对外接口只是一种静态定义，在代码静态解析阶段就会生成。

# 三、总结 #

*  CommonJS 用于 node 端，是同步加载的
 *  AMD 依赖于 requirejs,是异步加载的，是提前加载，立即加载
 *  CMD 依赖于 seajs ,是异步加载，延后加载，就近加载，用时加载

[参考:https://segmentfault.com/a/1190000017466120][https_segmentfault.com_a_1190000017466120]

[本文链接：https://blog.csdn.net/qq\_39903567/article/details/115325717][https_blog.csdn.net_qq_39903567_article_details_115325717]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5OTAzNTY3_size_16_color_FFFFFF_t_70]: /images/20221022/65e2cdb7d643464e908636967d20151b.png
[Link 1]: https://blog.csdn.net/qq_39903567/article/details/115010640
[https_segmentfault.com_a_1190000017466120]: https://segmentfault.com/a/1190000017466120
[https_blog.csdn.net_qq_39903567_article_details_115325717]: https://blog.csdn.net/qq_39903567/article/details/115325717