提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
文章目录
Node应用是由模块组成的，Node遵循了CommonJS的模块规范，来隔离每个模块的作用域，使每个模块在它自身的命名空间中执行。
一、CommonJS规范
1、什么是CommonJS规范
CommonJS 是一套代码规范, 目的是为了构建 JavaScript 在浏览器之外的生态系统 (服务器端, 桌面端). JavaScript 诞生之初只是为了写网页小脚本, 并不作为开发大型复杂应用的语言, 其自身有很多不足. 并且, 官方规范 (ECMAScript) 制定的时间较早, 涵盖范围较小, 对于后端开发而言, 例如文件系统, I/O 流, 模块系统, 等等方面都没有相应的标准. 基于种种的不足, CommonJS 规范致力于弥补 JavaScript 没有标准的缺陷, 让 JavaScript 有能力去开发复杂应用, 同时具备跨平台能力。
2、CommonJS规范的主要内容
模块必须通过 module.exports 导出对外的变量或接口，通过 require() 来导入其他模块的输出到当前模块作用域中。
3、CommonJS模块的特点
（1）所有代码运行在当前模块作用域中，不会污染全局作用域；
（2）模块同步加载，根据代码中出现的顺序依次加载；
（3）模块可以多次加载，但是只会在第一次加载时运行一次，然后运行结果就被缓存了，以后再加载，就直接读取缓存结果。要想让模块再次运行，必须清除缓存。
二、模块
模块：就是一个独立的功能体。
在NodeJS下，模块分为：自定义模块、核心模块、第三方模块。
在NodeJS下，每一个文件都是一个模块。
如果我们现在建立一个主文件（main.js），以及主文件需要引用的文件（second.js），即建立了两个模块。
NodeJS自动为每个文件添加了构造函数，所有的代码被构造函数包含：
(function(exports,require,module,__filename,__dirname){
程序员自己写的代码
})
1、require导入模块
（1）require()
require命令的基本功能是，读入并执行一个JavaScript文件，然后返回该模块的exports对象。如果没有发现指定模块，会报错。同一级目录写路径./，后缀名.js可以省略。
我们在second.js里写入如下代码：
console.log('haha')
var a = 1;
function fn(){
console.log(2);
}
然后在main.js里首先使用require引入secons.js，然后打印出它的结果，再打印一下它里面的创建的变量。
结果如上图：打印second.js里定义的变量时会报错，此时就需要用到另一个模块module。
（2）参数的加载规则
根据参数的不同格式，require命令去不同路径寻找模块文件。
1如果参数字符串以“/”开头，则表示加载的是一个位于绝对路径的模块文件。比如，require(’/home/marco/foo.js’)将加载/home/marco/foo.js。
2如果参数字符串以“./”开头，则表示加载的是一个位于相对路径（跟当前执行脚本的位置相比）的模块文件。比如，require(’./circle’)将加载当前脚本同一目录的circle.js。
3如果参数字符串不以“./“或”/“开头，则表示加载的是一个默认提供的核心模块（位于Node的系统安装目录中，如http，fs），或者一个位于各级node_modules目录的已安装模块（全局安装或局部安装）。例如，脚本/home/user/projects/foo.js执行了require(‘bar.js’)命令，Node会依次搜索以下文件。
/user/local/lib/node/bar.js
/home/user/projects/node_modules/bar.js
/home/user/node_modules/bar.js
/home/node_modules/bar.js
/node_modules/bar.js
这样设计的目的是，使得不同的模块可以将所依赖的模块本地化。
4如果参数字符串不以“./“或”/“开头，而且是一个路径，比如require(‘example-module/path/to/file’)，则将先找到example-module的位置，然后再以它为参数，找到后续路径。
5如果指定的模块文件没有发现，Node会尝试为文件名添加.js、.json、.node后，再去搜索。.js件会以文本格式的JavaScript脚本文件解析，.json文件会以JSON格式的文本文件解析，.node文件会以编译后的二进制文件解析。
6如果想得到require命令加载的确切文件名，使用require.resolve()方法。
（3）目录的加载规则
通常，我们会把相关的文件会放在一个目录里面，便于组织。这时，最好为该目录设置一个入口文件，让require方法可以通过这个入口文件，加载整个目录。在目录中放置一个package.json文件，并且将入口文件写入main字段。例如：
// package.json
{
"name" : "some-library",
"main" : "./lib/some-library.js"
}
require发现参数字符串指向一个目录以后，会自动查看该目录的package.json文件，然后加载main字段指定的入口文件。如果package.json文件没有main字段，或者根本就没有package.json文件，则会加载该目录下的index.js文件或index.node文件。
2、module导出模块
指代当前所在的模块对象。Node内部提供一个Module构建函数。所有模块都是Module的实例。
每个模块内部，都有一个module对象，代表当前模块。它有以下属性：
module.id：
模块的识别符，通常是带有绝对路径的模块文件名。 module.filename：
模块的文件名，带有绝对路径。
module.loaded：
返回一个布尔值，表示模块是否已经完成加载。
module.parent：
返回一个对象，表示调用该模块的模块。
module.children：
返回一个数组，表示该模块要用到的其他模块。
module.exports：
当前模块的导出对象，公开的属性和方法。表示当前模块对外输出的接口，其他文件加载该模块，实际上就是读取module.exports变量。
module.paths：
从当前文件目录开始查找node_modules目录；然后依次进入父目录，查找父目录下的node_modules目录；依次迭代，直到根目录下的node_modules目录。
如：
console.log(module.id);
console.log(module.filename);
下面这些模块都是我们自己写的，就是自定义模块。
我们在second.js里写入如下代码：
console.log('haha')
var a = 1;
function fn(){
console.log(2);
}
//使用module公开变量或者函数
//module.exports意思是要导出的对象
module.exports.vname = 'bear6';
module.exports.mya = a;
module.exports.fn = fn;
此时module导出了vname，mya，fn这些变量，main.js接收后就可以使用它们了。
3、expotrs
当然，导出时不但可以使用module.exports，也可以使用exports。
exports：指代module.exports
这等同在每个模块头部，有一行这样的命令。
var exports = module.exports;
举例如下：
second.js
console.log('haha')
var a = 1;
function fn(){
console.log(2);
}
//使用module公开变量或者函数
//module.exports意思是要导出的对象
exports.vname = 'bear6';
exports.mya = a;
exports.fn = fn;
此时，module.exports和exports里的地址指向的是同一导出对象。
我们可以直接导出匿名函数
second.js
module.exports.fn = function (){
console.log('haha');
}
main.js
当然，也可以直接导出对象，不过要注意，当导出对象时，exports与module.exports就不再指向同一个对象了。
second.js
module.exports = {
ename : 'tom',
say : function (){}
}
console.log(exports === module.exports)
main.js
由结果可以看出console.log(exports === module.exports)的打印结果为false。
注意：不能直接将exports变量指向一个值，因为这样等于切断了exports与module.exports的联系。
exports = function(x) {console.log(x)};
上面这样的写法是无效的，因为exports不再指向module.exports了。
下面的写法也是无效的。
exports.hello = function() {
return 'hello';
};
module.exports = 'Hello world';
上面代码中，hello函数是无法对外输出的，因为module.exports被重新赋值了。
这意味着，如果一个模块的对外接口，就是一个单一的值，不能使用exports输出，只能使用module.exports输出。
4、练习
（1）导出一个类
我们在haha.js里写入一个类，然后把它导出去，用heihei.js来接受它，并创建类的实例然后引用类的方法。
haha.js
class Person{
constructor(name,age) {
this.name = name;
this.age = age;
}
say = function (){
console.log("姓名为：",this.name);
}
hi(){
console.log("年龄为：",this.age);
}
}
module.exports = Person;
heihei.js
let Person = require('./haha');
let p1 = new Person('刘备',12);
let p2 = new Person('诸葛亮',33);
p1.say();
p2.hi();
结果如下：
（2）调用函数
创建两个模块main.js（主模块），circle（功能模块），在功能模块下创建两个函数，传递半径，计算圆的周长和面积，并导出两个函数，在主模块下引入功能模块，并调用两个函数。
main.js
//引入circle.js模块
var circle = require('./circle.js');
console.log('圆的面积为：',circle.getArea(4).toFixed(2));
console.log('圆的周长为：',circle.getLength(4).toFixed(2));
circle.js
//计算面积
function getArea(r){
return Math.PI * Math.pow(r,2);
}
//计算周长
function getLength(r){
return 2 * Math.PI * r;
}
//导出两个函数
module.exports.getArea = getArea;
module.exports.getLength = getLength;
5、__filename
代表当前模块的绝对目录和模块名称
6、__dirname
代表当前模块的绝对目录
7、模块的缓存
第一次加载某个模块时，Node会缓存该模块。以后再加载该模块，就直接从缓存取出该模块的module.exports属性。
如果想要多次执行某个模块，可以让该模块输出一个函数，然后每次require这个模块的时候，重新执行一下输出的函数。所有缓存的模块保存在require.cache之中，如果想删除模块的缓存，可以像下面这样写。
// 删除指定模块的缓存
delete require.cache[moduleName];
// 删除所有模块的缓存
Object.keys(require.cache).forEach(function(key) {
delete require.cache[key];
})
注意，缓存是根据绝对路径识别模块的，如果同样的模块名，但是保存在不同的路径，require命令还是会重新加载该模块。
三、引入目录模块具体讲解
1、引入以路径开头的目录模块
当引入以路径开头的目录模块时，它首先会找到此目录文件下的package.json文件，package.json文件里大多为对象，要求是，属性名必须用双引号括起来，如果属性值为字符串，也需要括起来，然后会寻找package.json中的main属性对应的文件名称，如果找不到就会引入此目录下的index.js。
练习：创建模块01.js，引入当前目录下的02目录模块，在02目录模块下有一个文件fun.js，导出一个函数sort（给一个数组顺序排序），在01.js中调用该函数。
目录格式如下：
fun.js：
//创建一个函数sort，功能是将一个数组顺序排序
function sort(arr){
for(let i = 1;i < arr.length;i++){
for(let j = i;j > 0;j--){
if(arr[j-1] > arr[j]) {
let temp = arr[j - 1];
arr[j - 1] = arr[j];
arr[j] = temp;
}
}
}
return arr;
}
//导出函数sort
module.exports.sort = sort;
package.json：
{
"name": "02",
"version": "1.0.0",
"dependencies": {
},
"main" : "fun.js"
}
我们使main属性的值为fun.js，这样当01.js引入02目录时，首先会引入02目录下的fun.js模块。
01.js：
//引入以路径开头的目录
let s = require('./02');
console.log(s.sort([4,55,3,11,29,0]));
结果如图：
2、引入不以路径开头的目录模块
引入不以路径开头的目录模块时，会自动到当前目录下的node_modules中寻找此目录，如果找不到node_modules，会往上一级查找直到*目录（如c盘），常用于引入第三方模块。
练习：创建目录03，在03下创建03_1.js引入不以路径开头的目录模块03_2，里面有文件foo.js，含有可以对数组进行逆序排序的fun函数，导出fun函数，并在03_1.js中调用函数。
目录格式如下：
foo.js：
//创建一个函数fun，功能为逆序排序
function fun(arr){
for(let i = 0;i < arr.length;i++){
for(let j = 0;j < arr.length-i-1;j++){
if(arr[j+1] > arr[j]){
let temp = arr[j+1];
arr[j+1] = arr[j];
arr[j] = temp;
}
}
}
return arr;
}
//导出fun函数
module.exports.fun = fun;
package.json：
{
"name": "03_2",
"version": "1.0.0",
"dependencies": {
},
"main" : "foo.js"
}
03_1.js：
//引入不以路径开头的03_2目录
var s = require('03_2');
console.log(s.fun([1,32,5,76,0,88]));
结果如下：
四、模块的循环加载
如果发生模块的循环加载，即A加载B，B又加载A，则B将加载A的不完整版本。
// a.js
exports.x = 'a1';
console.log('a.js ', require('./b.js').x);
exports.x = 'a2';
// b.js
exports.x = 'b1';
console.log('b.js ', require('./a.js').x);
exports.x = 'b2';
// main.js
console.log('main.js ', require('./a.js').x);
console.log('main.js ', require('./b.js').x);
上面代码是三个JavaScript文件。其中，a.js加载了b.js，而b.js又加载a.js。这时，Node返回a.js的不完整版本，所以执行结果如下。
修改main.js，再次加载a.js和b.js：
console.log('a.js中的x值为：',require('./a').x);
console.log('b.js中的x值为：',require('./b').x);
console.log('----end-----');
console.log('a.js中的x值为：',require('./a').x);
console.log('b.js中的x值为：',require('./b').x);
执行上面代码，结果如下：
上面代码中，第二次加载a.js和b.js时，会直接从缓存读取exports属性，所以a.js和b.js内部的console.log语句都不会执行了。
五、require的内部处理流程
require命令是CommonJS规范之中，用来加载其他模块的命令。它其实不是一个全局命令，而是指向当前模块的module.require命令，而后者又调用Node的内部命令Module._load。
Module._load = function(request, parent, isMain) {
// 1. 检查 Module._cache，是否缓存之中有指定模块
// 2. 如果缓存之中没有，就创建一个新的Module实例
// 3. 将它保存到缓存
// 4. 使用 module.load() 加载指定的模块文件，
// 读取文件内容之后，使用 module.compile() 执行文件代码
// 5. 如果加载/解析过程报错，就从缓存删除该模块
// 6. 返回该模块的 module.exports};
上面的第4步，采用module.compile()执行指定模块的脚本，逻辑如下：
Module.prototype._compile = function(content, filename) {
// 1. 生成一个require函数，指向module.require
// 2. 加载其他辅助方法到require
// 3. 将文件内容放到一个函数之中，该函数可调用 require
// 4. 执行该函数};
上面的第1步和第2步，require函数及其辅助方法主要如下：
require(): 加载外部模块
require.resolve()：将模块名解析到一个绝对路径
require.main：指向主模块
require.cache：指向所有缓存的模块
require.extensions：根据文件的后缀名，调用不同的执行函数
一旦require函数准备完毕，整个所要加载的脚本内容，就被放到一个新的函数之中，这样可以避免污染全局环境。该函数的参数包括require、module、exports，以及其他一些参数。
Module._compile方法是同步执行的，所以Module._load要等它执行完成，才会向用户返回module.exports的值。