一、前言
node的应用是模块组成的，Node遵循commonjs的模块规范，用来隔离每个模块的作用域，使每一个模块在自身的命名空间中执行。
commonjs的主要内容：
模块必须通过module.exports导出对外的变量或接口，通过require()来导入其他模块的输出到当前模块作用域中。
commonjs模块特点：
1、所有代码运行在当前模块作用域中，不会污染全局作用域。
2、模块同步加载，根据代码的顺序加载。
3、模块可以多次加载，只会在第一次加载时运行一次，然后运行结果会被缓存，以后再加载，就直接从缓存中读取结果，如若想要模块再次运行，必须清除缓存。
我们先来 看一下简单的例子
编写一个demo-exports.js
let name = 'saucxs';
let getName = function (name) {
console.log(name)
};
module.exports = {
name: name,
getName: getName
}我们再来编写一个demo-require.js
let person = require('./demo-export')
console.log(person, '-------------') // { name: 'saucxs', getName: [Function: getName] }
console.log(person.name, '===========') // saucxs
person.getName('gmw'); // gmw
person.name = 'updateName'
console.log(person, '22222222') // { name: 'updateName', getName: [Function: getName] }
console.log(person.name, '3333333') // updateName
person.getName('gmw') // gmwnode demp-require.js，结果如上所示。
二、module对象
commonjs规范，每一个文件就是一个模块，每一个模块中都有一个module对象，这个对象就指向当前模块。module对象具有如下属性：
（1）id：当前模块id。
（2）exports：表示当前模块暴露给外部的值。
（3）parent：是一个对象，表示调用当前模块的模块。
（4）children：是一个对象，表示当前模块调用的模块。
（5）filename：模块的绝对路径
（6）paths：从当前模块开始查找node_modules目录，然后依次进入到父目录，查找父目录下的node_modules目录；依次迭代，直到根目录下的node_modules目录。
（7）loaded：一个布尔值，表示当前模块是否被完全加载。
我们来看一下栗子
module.js
module.exports = {
name: 'saucxs',
getName: function (name) {
console.log(name)
}
}
console.log(module)node module.js
1、module.exports
我们知道了module对象有一个exports属性，该属性用来对外暴露变量，方法或者整个模块。当其他文件需要require该模块的时候，实际上读取的是module对象中的exports属性。
2、exports对象
既然都有了module.exports就能满足所有的需求，为啥还有一个exports对象呢？
我们现在来看一下两者的关系：
（1）exports对象和module.exports都是引用类型变量，指向同一个内存地址，在node中，两者一开始都是指向一个空对象的。
exports = module.exports = {}
（2）其次，exports对象是通过形参的方式传入，直接赋值给形参的引用，但是并不能改变作用域外的值。
var module = {
exports: {}
};
var exports = module.exports;
function change(exports) {
/*为形参exports添加属性name，会同步到外部的module.exports对象*/
exports.name = 'saucxs'
/*在这里修改wxports的引用，并不会影响到module.exports*/
exports = {
age: 18
}
console.log(exports) // {age: 18}
}
change(exports);
console.log(module.exports); // {exports: {name: 'saucxs'}}分析上述代码：
直接给exports赋值，会改变当前模块内部的形参exports的对象应用。说明当前的exports对象已经跟外部的module.exports对象没有任何关系，所以改变exports对象不会影响到module.exports。
注意：module.exports就是为了解决上述exports直接赋值的问题，会导致抛出不成功的问题而产生的。
//这些操作都是合法的
exports.name = 'saucxs';
exports.getName = function(){
console.log('saucxs')
};
//相当于下面的方式
module.exports = {
name: 'saucxs',
getName: function(){
console.log('saucxs')
}
}
//或者更常规的写法
let name = 'saucxs';
let getName = function(){
console.log('saucxs')
}
module.exports = {
name: name,
getName: getName
}这样就可以不用每次都把要抛出对象或者方法直接赋值给exports属性，直接采用对象字面量的方式更加方便。
三、require方法
require是模块的引入规则，通过exports或者module.exports抛出一个模块，通过require方法传入模块标识符，然后node根据一定的规则引入该模块，我们就可以使用模块中定义的方法和属性。
（一）node中引入模块的机制
1、在node中引入模块，需要经历3个步骤：
（1）路径分析
（2）文件定位
（3）编译执行
2、在node中，模块分为两种：
（1）node提供的模块，例如http模块，fs模块等，称为核心模块。核心模块在node源代码编译过程中就有编译了二进制文件，在node进程启动的时候，部分核心模块就直接加载进内存中，因此这部分模块是不用经历上述的(2),(3)步骤，而且在路径分析中优先判断，因此加载速度是最快的。
（2）用户自己编写的模块，称为文件模块。文件模块是需要按需加载的，需要经历上述的三个步骤，速度较慢。
3、优先从缓存中加载
浏览器会缓存静态脚本文件以提高页面性能一样，Node对引入过的模块也会进行缓存。与浏览器不同的是：Node缓存的是编译执行之后的对象而不是静态文件。我们举个例子看一下
requireA.js
console.log('模块requireA开始加载...')
exports = function() {
console.log('Hi')
}
console.log('模块requireA加载完毕')
init.js
var mod1 = require('./requireA')
var mod2 = require('./requireA')
console.log(mod1 === mod2)执行node init.js
虽然我们两次引入requireA这个模块，但是模块中的代码其实只执行了一遍。并且mod1和mod2指向了同一个模块。
4、module._load源码
Module._load = function(request, parent, isMain) {
// 计算绝对路径
var filename = Module._resolveFilename(request, parent);
// 第一步：如果有缓存，取出缓存
var cachedModule = Module._cache[filename];
if (cachedModule) {
return cachedModule.exports;
// 第二步：是否为内置模块
if (NativeModule.exists(filename)) {
return NativeModule.require(filename);
}
// 第三步：生成模块实例，存入缓存
var module = new Module(filename, parent);
Module._cache[filename] = module;
// 第四步：加载模块
try {
module.load(filename);
hadException = false;
} finally {
if (hadException) {
delete Module._cache[filename];
}
}
// 第五步：输出模块的exports属性
return module.exports;
};对应的流程如下：
（二）路径分析和文件定位
1、路径分析
模块标识符分析：
（1）核心模块，如http，fs模块。
（2）以 . 或者 ../ 开始的相对路径文件模块。
（3）以 / 开始的绝对路径模块。
（4）非路径形式的文件模块。
分析：
（1）核心模块：优先级仅次于缓存，加载速度最快。如果自定义模块和核心模块名称相同，加载会失败。若想成功，必须修改自定义模块的名称或者换个路径。
（2）路径形式的文件模块：以 . 或者 .. 或者 / 开始的标识符，都会被当做文件模块来处理。加载过程中，require方法将路径转换为真实的路径，加载速度仅次于核心模块。
（3）非路径形式的自定义模块：这是一种特殊的文件模块，可能是一个文件或者包的形式。查找这类模块的策略类似于js作用域链，node会逐个尝试模块路径中的路径，知道找到目标文件为止。
注意：这是node定位文件模块的具体文件的时候的查找策略，具体表现为一个路径的组成的数组。
可以在REPL环境中输出Module对象，查看其path属性的方式查看上述数组，文章开始的paths数组：
2、文件定位
（1）文件拓展名分析
require()分析的标识符可以不包含扩展名，node会按.js、.node、.json的次序补足扩展名，依次尝试
（2）目标分析和包
如果在扩展名分析的步骤中，查找不到文件而是查找到相应目录，此时node会将目录当做包来处理，进行下一步分析查找当前目录下package.json中的main属性指定的文件名，若查找不成功则依次查找index.js,index.node,index.json。
如果目录分析的过程中没有定位到任何文件，则自定义模块会进入下一个模块路径继续查找，直到所有的模块路径都遍历完毕，依然没找到则抛出查找失败的异常。
（3）参考源码
在Module._load方法的内部调用了Module._findPath这个方法，这个方法是用来返回模块的绝对路径的，源码如下：
Module._findPath = function(request, paths) {
// 列出所有可能的后缀名：.js，.json, .node
var exts = Object.keys(Module._extensions);
// 如果是绝对路径，就不再搜索
if (request.charAt(0) === '/') {
paths = [''];
}
// 是否有后缀的目录斜杠
var trailingSlash = (request.slice(-1) === '/');
// 第一步：如果当前路径已在缓存中，就直接返回缓存
var cacheKey = JSON.stringify({request: request, paths: paths});
if (Module._pathCache[cacheKey]) {
return Module._pathCache[cacheKey];
}
// 第二步：依次遍历所有路径
for (var i = 0, PL = paths.length; i < PL; i++) {
var basePath = path.resolve(paths[i], request);
var filename;
if (!trailingSlash) {
// 第三步：是否存在该模块文件
filename = tryFile(basePath);
if (!filename && !trailingSlash) {
// 第四步：该模块文件加上后缀名，是否存在
filename = tryExtensions(basePath, exts);
}
}
// 第五步：目录中是否存在 package.json
if (!filename) {
filename = tryPackage(basePath, exts);
}
if (!filename) {
// 第六步：是否存在目录名 + index + 后缀名
filename = tryExtensions(path.resolve(basePath, 'index'), exts);
}
// 第七步：将找到的文件路径存入返回缓存，然后返回
if (filename) {
Module._pathCache[cacheKey] = filename;
return filename;
}
}
// 第八步：没有找到文件，返回false
return false;
};（三）清除缓存
根据上述的模块引入机制我们知道，当我们第一次引入一个模块的时候，require的缓存机制会将我们引入的模块加入到内存中，以提升二次加载的性能。但是，如果我们修改了被引入模块的代码之后，当再次引入该模块的时候，就会发现那并不是我们最新的代码，这是一个麻烦的事情。如何解决呢？
require(): 加载外部模块
require.resolve()：将模块名解析到一个绝对路径
require.main：指向主模块
require.cache：指向所有缓存的模块
require.extensions：根据文件的后缀名，调用不同的执行函数解决办法：
//删除指定模块的缓存
delete require.cache[require.resolve('/*被缓存的模块名称*/')]
// 删除所有模块的缓存
Object.keys(require.cache).forEach(function(key) {
delete require.cache[key];
})然后我们再重新require进来需要的模块就可以了。