CommonJS模块
CommonJS是一种规范，它定义了JavaScript 在服务端运行所必备的基础能力，比如：模块化、IO、进程管理等。其中，模块化方案影响深远，其对模块的定义如下：
1，模块引用：使用require() 方法引用模块，它接受模块标识作为参数，将一个模块引入到当前运行环境中。
2，模块定义：使用exports对象，导出当前模块的方法或者变量，并且它是唯一的导出出口。
3，模块标识：就是模块的名字，传递给 require() 方法的参数。
如果JS文件中存在 exports 或 require，该 JS文件就是一个模块，模块内的所有代码均为 隐藏代码，包括变量、函数，对其他文件不可见，也不会对全局变量造成污染。如果一个模块需要暴露一些API给外部使用，需要通过exports 导出，exports 是一个空对象，你可以为该对象添加任何需要导出的内容。如果一个模块需要导入其他模块，通过require 实现，require 是一个函数，传入模块的路径即可返回该模块导出的整个内容。
Node.js 实现了CommonJS 模块，它主要做了三件事情，路径的解析，文件的查找，编译执行，就是当require一个模块标识时，怎么才能找到模块，并把exports对象获取到，引入当前运行环境中。模块标识是一个字符串，它主要有两种情况，以'/，'./' 或'../' 为主的路径和没有路径标识的字符串。如果是路径，就直接查找路径对应的模块。如果不是路径，Node.js先查找是不是核心模块，比如fs，http，如果不是，就在当前目录下的 node_modules 目录查找，如果没有，在父级目录的 node_modules 查找，如果没有，在父级目录的父级目录的 node_modules 中查找。沿着路径向上递归，直到根目录下的 node_modules 目录。
找到路径，它可以是一个文件，它还可以是一个文件夹。如果是一个文件，还会看有没有后缀，如果有，它就会直接加载文件。如果没有后比缀，它就会先查找.js，再查找.json，最后查找.node文件。 如果路径指的是一个文件夹，它先查找有没有package.json文件，如果有，就会找 package.json 下 main 属性指向的文件，如果没有 package.json ，在 node 环境下会以index.js ，index.json ，index.node。也就是说，在Node.js中，模块可以是一个文件，也可以是一个文件夹，还可以是一个包。包就是一个文件夹中包含package.json。只要使用require方法引入的，都称为模块。
找到了要加载的文件，为了隐藏模块中的代码，同时提供export 和require方法，nodejs 执行模块时，会将模块中JS代包括到一个函数中。
(function (exports, require, module, __filename, __dirname) {
// 模块中的js代码
})
当然，为了高效的执行，Node.js在CommonJS模块上做了一些改进，
1，运行时加载：Node.js 执行到require函数时才会加载模块并执行，然后将模块的exports对象返回。加载模块是同步的，只有当模块加载完成后，才能执行后面的操作。加载，执行，返回exports对象， require就像一个普通的函数调用，把返回值exports对象赋值给一个变量。比如number.js
let num = 1
function add() {
num++
}
exports.num = num
exports.add = add
在index.js中引入
const number = require('./number.js')
console.log(number.num)
当require('./number.js')时，Node.js执行number.js，exports.num = 1; exports.add = add, 执行完毕，然后把exports对象返回，相当于把{num:1, add: add} 对象赋值给index.js中的number，require函数执行完华，number变量和模块就没有关系了。这时即使调用number.add() 也不会必改变number 对象中num的值，因为add函数引用的是它自己作用域中的num，而不是index.js中number对象的属性。相反，你可以把修改number变量中num属性的值。
number.add() console.log(number.num) //1 number.num = 3 console.log(number.num) //3
2，缓存：当require一个模块时，会先将模块缓存，然后执行代码，以后再加载该模块时，就直接从缓存中读取该模块。比如a.js
console.log('a 模块加载')
exports.a = 'a'
b.js
console.log('b 模块加载')
const moduleA = require('./a.js');
exports.b = 'b'
index.js
const a = require('./a')
const b = require('./b')
执行index.js，可以发现a模块只加载了一次。当b.js中再require a.js时，a.js已经缓存了，所以就没有加载，执行了。模块的缓存也有助于解决循环依赖。a.js改为
const { getMes } = require('./b')
console.log('我是 a 文件')
exports.say = function () {
const message = getMes()
console.log(message)
}
b.js
const say = require('./a');
console.log('我是 b 文件')
exports.getMes = function(){return "Hello"}
执行index.js，先加载a.js 放入缓存中，然后执行a.js，它又加载 b.js，b.js放入缓存，并执行，它又引入a.js，因为a模块已经在缓存中，所以直接读取缓存中的a, 实现上缓存中的a模块，只是一个空对象，加载完之后，b.js继续执行，控制台输出"我是b文件"。b.js执行完以后，再执行a.js，输出 “我是b文件”
当然，也可以删除缓存，缓存是按照路径的形式将模块进行缓存，放到 require.cache对象上。通过delete require.cache[modulePath]将缓存的模块删除。需要注意的是modulePath是绝对路径。
3，exports 和 module.exports。CommonJS模块化只规定exports对象向外导出。想要导出什么，只给exports对象，添加属性，但只想导出方法，对象就有点麻烦，所以Node.js 可以直接使用module.exports 进行导出。
(function(module){
module.exports = {};
var exports = module.exports
// a.js 写入的代码
exports.a = 'a';
return module.exports;
})()
到了commonjs2，也规定，可以用module.exports进行导出。
ES模块
ES模块是ECMAScript官方推出的模块化解决方案，它吸取CommonJS的优点，一个JS文件就是一个独立模块，模块内部的变量都是私有化的，其他模块无法访问；要想让其它模块进行访问，就要暴露出去，其它模块需要引入才能使用。但语法更简洁
1，使用export 导出模块，不仅可以export对象，还可以export 变量，函数等，其实，在ES模块下，可以导出任意的标识符
export const a = 'a';
export function sayHello() { console.log('hello , world') }
export导出的是标识符，也就是内存地址，而不是值，所下面两种是错误的写法：
// 报错，是个值= export 1; var m = 1; export m;
2，使用 import并配合 from关键词进行导入。注意，from后面的文件名要加后缀。
import { a, sayHello } from'./a.js' //引入的文件要加后缀名
import 导入的就是变量名, 相当于内存地址，因此，导入的是只读引用，不能修改a 和sayHello 的值。也正因为是import的是变量名，导出模块内部的变量一旦发生变化，对应导入模块的变量也会跟随变化。
3，以上的import 和export 称为有名字的import和 export。ES模块还定义default export和import。就是导出的时候，使用 export default,
export default class Logger {
log (message) {
console.log(`${message}`)
}
}
导出是default， 而不是Logger，导出的内容被注册到default上，所以后面的logger 被忽略了， 正是由于导出的是default，所以export default 后面跟的是值，而不是变量， default在某种意义上来说，可以称为变量声明了，所以需要提供值。
export default 1; // 正确 export default const a = 1; // 错误
导出default 还有一个影响, 就是，一个模块中只能有一个默认的导出。默认导出的import 是
import MyLogger from './logger.js'
导入的时候，不加{}， 并且可以随意命名变量。实际上在内部，模块导出的就是default
import * as loggerModule from './logger.js'
console.log(loggerModule) // [Module] { default: [Function: Logger] }
但你不能是用 import {default} from './logger.js'，语法错误，defautl是关键字。
4，模块标识符(要import的模块的位置）：
相对路径标识符，就是 ‘./a.js’, '../a.js'
绝对路径标识符: file:// 本地url, 比如"file:///opt/nodejs/config.js" , ES 模块绝对路径标识符，只有这一种格式，直接使用/ 或// 作为绝对路径不起作用
无路径标识符，就是node 核心模块和node_modules中的第三方包，比如 fs, http 和fastify
深度import 标识符，比如fastify/lib/logger.js。node_modules中fastify下的lib下的logger.js
5，ES模块的加载方式是静态化的，只有在编译时加载，不会在执行时加载，也就是说引入模块的语句必须在模块的最顶层，不能在任何控制语句中。并且引入的模块名称也只能是常量字符串，不能是需要运行期动态求值的表达式，因为编译不会运算求值。静态化加载，也有好处，比如也可以是异步的。如果想要动态加载模块，只能调用import()函数，它接受模块标识符作为参数，返回一个promise, promise resolve之后，就是模块对象。
Node 14中实现了ES 模块，来看一下它是怎么解析和执行ES模块的? 从入口文件开始，沿着import语句，寻找模块，构建整个项目的模块依赖图(dependency graph)，从而确定各个模块之间的依赖关系和代码运行时的模块的执行顺序。 这个过程又分为三个阶段
1，构建或解析阶段，从入口文件开始，分析它的import，加载依赖模块。依赖模块又有依赖，再根据imort加载它的依赖，层层递归，直到依赖没有依赖为止。加载依赖的过程中，会把加载完成的依赖缓存起来，如果以后再加载相同的依赖，就不执行加载操作。每加载一个模块就会生成一个模块记录，其中的importEntries字段就记录着模块的依赖。
加载好的模块缓存到 modulemap中
2， 实例化阶段：把每一个export 实体(导出的变量)都放到内存指定位置，将对应关系存储到模块环境记录(module environment record)中，但不会给变量赋值。import也指向这个内存地址，设置模块导入和内存的对应关系，确保相同变量的导入和导出都指向了同一个内存区域，并保证所有的导入都能找到对应的导出。导出和导入都指向内存指定位置，称为linking，在这一阶段，没有JS代码会执行。
执行阶段：执行代码，得到变量的值然后放到内存对应位置，实例化阶段的实体都会获取到真正的值。此时，可以从入口文件开始执行代码，整个项目开始执行。
这三个阶段相互分离，在构建完整个依赖图之前，没有代码会执行，因此模块的导入或导出都是静态的。
理解了模块的加载，看一下ES模块是怎么处理循环依赖的？
// a.js
import * as bModule from './b.js'
export let loaded = false
export const b = bModule
loaded = true
// b.js
import * as aModule from './a.js'
export let loaded = false
export const a = aModule
loaded = true
// main.js
import * as a from './a.js'
import * as b from './b.js'
console.log('a ->', a)
console.log('b ->', b)
解析阶段：node main.js，main.js就是入口文件。main.js 加载a.js, a.js加载b.js，b.js再加载a.js，因为，a.js已经加载过了，就不加载了，它也没有其它import，直接返回到a.js，a.js也没有其它import，就返回到main.js，main.js再加载b.js，由于b.js已经加载过了，也就不加载了，注意，这里只执行inport 加载，不执行代码。
2， 实例化阶段，根据第一阶段得到的依赖树，从下到上遍历，对于每一个模块，解释器找到所有export出来的属性，然后，再建立build out a map of the exported names
in memory:
从b.js开始，它export出了loaded 和a， 再到a.js，它也export出了loaded 和b，最后到main.js， 它没有export什么。注意，图中exports 映射只track export出来的名字，值没有初始化。再link the exported names to the modules importing them
所有的值仍然是未初始化的。
执行阶段，每一个文件中的所有代码最终执行。执行顺序，也是沿着依赖图从下到上执行。b.js先执行，loaded设为false，a指向代表a.js模块的aModule, loaded再调为true. 至此b.js执行完了，再执行a.js, loaded设为false，b指向模块b.js，loaded重置为御true, a.js也执行完了，再执行main.js, 所有export出来的属性都执行完了，引入的模块a, b 都是引用，直接找到a, b 进行输出。在ES 模块中，每一个模块都能引用到其它模块实时更新的或最新的状态。
模块使用
Node.js 中同时存在两种模块机制，要怎么使用呢？.js文件默认是CommonJS模块(语法)，不能使用ESM语法，否则报错。要想使用ESM语法，可以把文件命名为.mjs，或者文件名是.js, 但在项目的package.json中加个type字段, 值为"module", "type": "module"，为了后者进行对应，CommonJS解析也进行了相应的变化，1，文件以.cjs结尾，2，如果有package.json, package.json中没有type 字段或type 字段设为comonjs, 以 .js结尾的文件以CommonJS 解析。因此，Node.js 团队强烈建议包的作者在package.json文件中注明type 字段
{
"type": "module"
}
当使用CommonJS时，Node向模块中注入了__dirname, __firename 等全局对象。但ES模块是通过 import/export关键词来实现，没有对应的函数包裹，所以在 ES模块中，没法使用这些CommonJS对象。但可能通过import.meta来获取到当前文件的URL的引用。import.meta是 ECMA 实现的一个包含模块元数据的特定对象，主要用于存放模块的 url，而 node 中只支持加载本地模块，所以 url 都是使用 file:协议。import.meta.url is a reference to the current module
file in a format similar to file:///path/to/current_module.js. This value can be
used to reconstruct __filename and __dirname in the form of absolute paths:
import { fileURLToPath } from 'url';
import {dirname} from 'path';
const __firname = fileURLToPath(import.meta.url);
const __dirname = dirname(__firname);
在ES模块文件中，可以引用CommonJS模块的内容，使用default import可以import进来CommonJS模块exports出来的整个对象， 使用name import 可以单独import 进来CommonJS模块exports出来的某个属性。假设cmj.js中 exports.a = 3; 在m.mjs 中，
import aa from './cmj.js' // 整个对象 {a: 3}
import {a} from './cmj.js' // 单个属性 a, 3
在CommonJS模块文件中，也可以引用ES 模块中的内容， 不过，不能使用require， 而是使用import()函数，动态加载。
import('./m.mjs').then(data => {
console.log(data) // [Module] { a: 3 }
})
有些包还包含子包，除了直接引用整个包外，Node.js还允许我们引用包里的某个模块。这时require 或import接受的文件标识符参数，就变成了包名/引用的模块。以mine包为例，你可以 require('mine') 引用整个包，也可以引用require('mine/lite'). import 就是import 'mine' 或import 'mine/lite'。如果遇到这样的模块标识符， Node.js先在node_moudules中找到主包，在这里是mine。然后再根据模块标识符找主包下面的文件。模块标识符也标识出了路径，mine目录下面的lite(主包mine也是一个目录)，lite可以是lite.js, 也可以是lite目录，它里面包含index.js。
像这种深入引用的模块标识符，包的作者也可以在package.json中定义，而不用使用上面的路径对应的方式。
{
"exports": {
"./cjsmodule": "./src/cjs-module.js",
"./es6module": "./src/es6-module.mjs"
}
}
require('module-name/cjsmodule') or import 'module-name/es6module' ， 就可以加载相应的子模块或子包。
标签：Node,exports,js,export,模块,import,加载 From： https://www.cnblogs.com/SamWeb/p/16310650.html