HUA
首页/文章/javascript

理解amd,cmd,commonjs,esm,umd 模块化

2024-03-06
4209 字约 15 分钟
...
学习面试

什么是模块

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

模块化的进化过程

1.全局function模式

将不同的功能封装成不同的全局函数

  • 编码：将不同的功能封装成不同的全局函数
  • 问题：污染全局命名空间, 容易引起命名冲突或数据不安全，而且模块成员之间看不出直接关系
function m1(){
  
}
function m2(){
  
}

2.namespace模式

简单对象封装

  • 作用：减少了全局变量，解决命名冲突
  • 问题：数据不安全(外部可以直接修改模块内部的数据)
let myModule = {
  data: 'www.baidu.com',
  foo() {
    console.log(`foo() ${this.data}`)
  },
  bar() {
    console.log(`bar() ${this.data}`)
  }
}
myModule.data = 'other data' 
myModule.foo()

这样的写法会暴露所有模块成员，内部状态可以被外部改写。

3.IIFE模式

匿名函数自调用(闭包)

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

<script type="text/javascript" src="module.js"></script>
<script type="text/javascript">
    myModule.foo()
    myModule.bar()
    console.log(myModule.data) 
    myModule.data = 'xxxx' 
    myModule.foo() 
</script>


(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 } 
})(window)

最后得到的结果：

foo() www.baidu.com
bar() www.baidu.com
undefined
foo() www.baidu.com

4.IIFE模式增强

这就是现代模块实现的基石


(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)

 
<!-- 引入的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>

上例子通过jquery方法将页面的背景颜色改成红色，所以必须先引入jQuery库，就把这个库当作参数传入。这样做除了保证模块的独立性，还使得模块之间的依赖关系变得明显。

5.模块化的好处

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

6.引入多个script后出现出现问题

  • 引入顺序

一旦引入顺序出现问题，就可能报错

  • 请求过多

首先我们要依赖多个模块，那样就会发送多个请求，导致请求过多； 同一个域名下限制6个tcp连接，一旦有多个请求，某些请求时间较长时，用户体验感就会大打折扣

  • 依赖模糊

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

  • 难以维护

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

CommonJS

1.概念

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

2.特点

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

3.基本语法

  • 暴露模块：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

上面代码通过module.exports输出变量x和函数addX。

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

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

模块的加载机制

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

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

上面代码输出内部变量counter和改写这个变量的内部方法incCounter。

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

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

上面代码说明，counter输出以后，lib.js模块内部的变化就影响不到counter了。这是因为counter是一个原始类型的值，会被缓存。除非写成一个函数，才能得到内部变动后的值。

服务器端实现

  1. 安装node
  2. npm init
|-modules
  |-module1.js
  |-module2.js
  |-module3.js
|-app.js
|-package.json
  {
    "name": "commonJS-node",
    "version": "1.0.0"
  }
  1. 下载第三方模块
npm install uniq --save
  1. 定义模块代码

module.exports = {
  msg: 'module1',
  foo() {
    console.log(this.msg)
  }
}


module.exports = function() {
  console.log('module2')
}


exports.foo = function() {
  console.log('foo() module3')
}
exports.arr = [1, 2, 3, 3, 2]



let uniq = require('uniq')
let module1 = require('./modules/module1')
let module2 = require('./modules/module2')
let module3 = require('./modules/module3')

module1.foo() 
module2() 
module3.foo() 
console.log(uniq(module3.arr))
  1. node app.js

浏览器端实现

使用Browserify：Browserify 会对代码进行解析，整理出代码中的所有模块依赖关系，然后把相关的模块代码都打包在一起，形成一个完整的JS文件，这个文件中不会存在 require 这类的模块化语法，变成可以在浏览器中运行的普通JS

  1. 创建项目结构
|-js
  |-dist 
  |-src 
    |-module1.js
    |-module2.js
    |-module3.js
    |-app.js 
|-index.html 
|-package.json
  {
    "name": "browserify-test",
    "version": "1.0.0"
  }
  1. 下载browserify
  • 全局: npm install browserify -g
  • 局部: npm install browserify --save-dev
  1. 定义模块代码

注意：index.html文件要运行在浏览器上，需要借助browserify将app.js文件打包编译，如果直接在index.html引入app.js就会报错！

  1. 打包处理js

根目录下运行

browserify js/src/app.js -o js/dist/bundle.js
  1. 页面使用引入

在index.html文件中引入

<script type="text/javascript" src="js/dist/bundle.js"></script>

AMD（Asynchronous Module Definition）

  1. 概念

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

  1. 基本语法

定义暴露模块：


define(function(){
   return 模块
})


define(['module1', 'module2'], function(m1, m2){
   return 模块
})

引入使用模块：

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

  1. AMD实现

通过比较是否使用AMD，来说明使用AMD实际使用的效果。

  1. 未使用AMD规范


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


(function (window, dataService) {
  let name = 'baidu'
  function showMsg() {
    alert(dataService.getMsg() + ', ' + name)
  }
  window.alerter = {showMsg}
})(window, dataService)


(function (alerter) {
  alerter.showMsg()
})(alerter)


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

最后得到如下结果：

'www.baidu.com', 'baidu'

这种方式缺点很明显：首先会发送多个请求，其次引入的js文件顺序不能搞错，否则会报错

  1. 使用require.js

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

接下来介绍AMD规范在浏览器实现的步骤：

  1. 下载require.js, 并引入

然后将require.js导入项目: js/libs/require.js

  1. 创建项目结构
|-js
  |-libs
    |-require.js
  |-modules
    |-alerter.js
    |-dataService.js
  |-main.js
|-index.html
  1. 定义require.js的模块代码


define(function() {
  let msg = 'www.chenghuai.com'
  function getMsg() {
    return msg.toUpperCase()
  }
  return { getMsg } 
})



define(['dataService'], function(dataService) {
  let name = 'chenghuai'
  function showMsg() {
    alert(dataService.getMsg() + ', ' + name)
  }
  
  return { showMsg }
})


(function() {
  require.config({
    baseUrl: 'js/', 
    paths: {
      
      alerter: './modules/alerter', 
      dataService: './modules/dataService'
    }
  })
  require(['alerter'], function(alerter) {
    alerter.showMsg()
  })
})()


<!DOCTYPE html>
<html>
  <head>
    <title>Modular Demo</title>
  </head>
  <body>
    
    <script data-main="js/main" src="js/libs/require.js"></script>
  </body>
</html>
  1. 页面引入require.js模块

在index.html引入

<script data-main="js/main" src="js/libs/require.js"></script>
  1. 引入第三方库

define(['dataService', 'jquery'], function(dataService, $) {
  let name = 'Tom'
  function showMsg() {
    alert(dataService.getMsg() + ', ' + name)
  }
  $('body').css('background', 'green')
  
  return { showMsg }
})


(function() {
  require.config({
    baseUrl: 'js/', 
    paths: {
      
      alerter: './modules/alerter', 
      dataService: './modules/dataService',
      
      jquery: './libs/jquery-1.10.1' 
    }
  })
  require(['alerter'], function(alerter) {
    alerter.showMsg()
  })
})()

上例是在alerter.js文件中引入jQuery第三方库，main.js文件也要有相应的路径配置。

  1. 总结

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

CMD（Common Module Definition）

  1. 概念

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

  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()
})

CMD实现

  1. 下载sea.js, 并引入

然后将sea.js导入项目：js/libs/sea.js

  1. 创建项目结构
|-js
  |-libs
    |-sea.js
  |-modules
    |-module1.js
    |-module2.js
    |-module3.js
    |-module4.js
    |-main.js
|-index.html
  1. 定义sea.js的模块代码

define(function (require, exports, module) {
  
  var data = 'chenghuai.com'
  
  function show() {
    console.log('module1 show() ' + data)
  }
  
  exports.show = show
})


define(function (require, exports, module) {
  module.exports = {
    msg: 'I am chenghuai'
  }
})


define(function(require, exports, module) {
  const API_KEY = 'abc123'
  exports.API_KEY = API_KEY
})


define(function (require, exports, module) {
  
  var module2 = require('./module2')
  function show() {
    console.log('module4 show() ' + module2.msg)
  }
  exports.show = show
  
  require.async('./module3', function (m3) {
    console.log('异步引入依赖模块3  ' + m3.API_KEY)
  })
})


define(function (require) {
  var m1 = require('./module1')
  var m4 = require('./module4')
  m1.show()
  m4.show()
})
  1. 在index.html中引入
<script type="text/javascript" src="js/libs/sea.js"></script>
<script type="text/javascript">
  seajs.use('./js/modules/main')
</script>

最后得到结果如下：

module1 show(), chenghuai
module4 show() I am chenghuai
异步引入依赖模块3 abc123

  1. AMD与CMD区别


define(function (requie, exports, module) {
    
    var module1 = require('Module1');
    var result1 = module1.exec();
    module.exports = {
      result1: result1,
    }
});


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

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

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

ESM 下模块之间的依赖关系是高度确定的，与运行状态无关，编译工具只需要对 ESM 模块做静态分析，就可以从代码字面量中推断出哪些模块值未曾被其它模块使用，这是实现 Tree Shaking 技术的必要条件。

ES6模块化

  1. 概念

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

  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 function () {
  console.log('foo');
}


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

模块默认输出, 其他模块加载该模块时，import命令可以为该匿名函数指定任意名字。

ES6 模块与 CommonJS 模块的差异

  1. CommonJS 模块输出的是一个值的拷贝，ES6 模块输出的是值的引用；

  2. CommonJS 模块是运行时加载，ES6 模块是编译时输出接口；

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

下面重点解释第一个差异，我们还是举上面那个CommonJS模块的加载机制例子:

es6


export let counter = 3;
export function incCounter() {
  counter++;
}

import { counter, incCounter } from './lib';
console.log(counter); 
incCounter();
console.log(counter);

commonjs

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

ES6 模块的运行机制与 CommonJS 不一样。ES6 模块是动态引用，并且不会缓存值，模块里面的变量绑定其所在的模块。

  1. ES6实现

简单来说就一句话：使用Babel将ES6编译为ES5代码，使用Browserify编译打包js。

  1. 定义package.json文件
 {
   "name" : "es6-babel-browserify",
   "version" : "1.0.0"
 }
  1. 安装babel-cli, babel-preset-es2015和browserify
npm install babel-cli browserify -g
npm install babel-preset-es2015 --save-dev
  1. 定义.babelrc文件
  {
    "presets": ["es2015"]
  }
  1. 定义模块代码


export function foo() {
  console.log('foo() module1')
}
export function bar() {
  console.log('bar() module1')
}



function fun1() {
  console.log('fun1() module2')
}
function fun2() {
  console.log('fun2() module2')
}
export { fun1, fun2 }



export default () => {
  console.log('默认暴露')
}


import { foo, bar } from './module1'
import { fun1, fun2 } from './module2'
import module3 from './module3'
foo()
bar()
fun1()
fun2()
module3()
  1. 编译并在index.html中引入
  • 使用Babel将ES6编译为ES5代码(但包含CommonJS语法) : babel js/src -d js/lib
  • 使用Browserify编译js : browserify js/lib/app.js -o js/lib/bundle.js

然后在index.html文件中引入

 <script type="text/javascript" src="js/lib/bundle.js"></script>

最后得到如下结果：

foo() module1
bar() module1
fun1() module2
fun2() module2
默认暴露
  1. 引入第三方库 首先安装依赖npm install jquery@1，然后在app.js文件中引入

import { foo, bar } from './module1'
import { fun1, fun2 } from './module2'
import module3 from './module3'
import $ from 'jquery'

foo()
bar()
fun1()
fun2()
module3()
$('body').css('background', 'green')

UMD（Universal Module Definition）

是一种javascript通用模块定义规范，让你的模块能在javascript所有运行环境中发挥作用。

意味着要同时满足CommonJS, AMD, CMD的标准，以下为实现：

(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模块'
    }
}))

总结

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

如果您觉得这篇文章有帮助，请点个赞吧～

分享文章

相关文章

更多文章 →
javascript2025-09-18
JavaScript 的多线程能力：Worker
如果你写过一些计算量稍大的 JavaScript 代码，比如图像处理、大量数据排序或者复杂的算法，你几乎肯定遇到过浏览器“卡死”的现象。点击页面没反应，动画也停了，就像整个世界都静止了。 这就是主线程被阻塞的典型后果。因为主线程既要负责执行 JavaScript，又要负责渲染页面、响应用户操作，一旦它被繁重的计算任务占满，就无暇顾及其他，用户体验便直线下降。 这个问题的根源，正是“主线程是单线程的”。那么，如何解决呢？ 答案很简单：把这...
学习面试
javascript2025-09-10
手把手教你实现一个EventEmitter
你是不是也遇到过这种情况：代码里各种事件监听和触发，回调函数套了一层又一层，最后自己都理不清哪个事件先触发、哪个后触发了？ 别担心，今天我就带你从零开始实现一个自己的事件触发器（EventEmitter），让你彻底掌握事件驱动的精髓，代码清晰度直接提升200%！ 为什么要懂EventEmitter？ 先说说为什么我们要关心这个。Node.js的核心就是事件驱动，比如文件读写、网络请求，都是通过事件来处理的。不会EventEmitter，...
学习面试
javascript2025-08-09
Web Worker 多线程魔法
你是否曾遇到过网页因为复杂计算而卡顿的情况？今天，让我们一起探索Web Worker的神奇世界，看看如何用多线程技术解决性能瓶颈，并实现流畅的图片压缩功能！ 为什么需要Web Worker？ 想象一下，你在一个繁忙的餐厅里，只有一位服务员（主线程）负责点餐、上菜、结账所有工作。当客人突然暴增时，这位服务员就会手忙脚乱，其他客人只能干等着… 这就是JavaScript的现状—— 单线程 ！所有任务都在一个线程中排队执行，一旦遇到复杂计算（...
学习面试
javascript2025-08-07
🌐AST抽象语法树
AST 是前端开发中一个非常重要的概念，它就像是代码的“编译器”，能够帮助我们理解和操作代码。本文将深入探讨 AST 的原理和应用，带你从零开始了解 AST。 一、什么是 AST？ AST（抽象语法树）是一种树形结构，用于表示程序代码的语法结构。它将代码分解为一系列的节点，每个节点代表代码中的一个元素，如变量、函数、表达式等。AST 是编译器和解释器的基础，也是代码分析和转换的关键工具。 1\. AST 的结构 AST 的结构通常包括以...
学习面试
javascript2025-08-05
打字机效果是如何实现的
分析效果 使用 AI 对话的时候，文字是一个字一个字蹦出来的？它不是等所有内容生成完毕后一次性展示，而是以一种流畅、实时的“打字机”效果呈现，这种体验的背后，隐藏着一种高效的Web技术。它就是 服务器推送事件（Server Sent Events，简称 SSE） 什么是 SSE 从根本上说，SSE 是一种允许服务器 单向 、 持续 地向客户端（浏览器）推送数据的Web技术。 可以把它想象成一个 电台广播 ： 服务器 是广播电台，持续不断...
学习面试
javascript2025-08-04
Promise 从原理到实现
前言 是 异步编程的核心概念之一，它为我们提供了一种更优雅的方式来处理异步操作。 本文将全面剖析 的工作原理，并逐步实现一个符合 规范的 。 正文 一、Promise 基础概念 代表一个异步操作的最终完成（或失败）及其结果值。它有 种状态： 1. pending ： ，既不是成功，也不是失败状态 2. fulfilled ：意味着操作 完成 3. rejected ：意味着操作 状态一旦改变就不能再变，只能从 变为 ，或从 变为 。 二...
学习面试

评论

请登录后发表评论

去登录
加载评论中...

目录