本文参考Node.js v8.1.3 Documentation。
在 Node.js 中，文件和模块是一一对应的，一个文件就是一个独立的模块。
模块内， Function 和 object 通过exports对象的方法添加到模块根部。
模块容器
模块内的变量是私有的。因为在Node.js 中，模块被执行前，是包裹在函数容器里的。
(function(exports, require, module, __filename, __dirname) {
// Module code actually lives in here
});
这么做除了实现特定于模块的全局变量时，也能使，用let等声明的变量不在全局声明。换句话说，如果我不用let在模块内声明变量，那这个变量是定义在全局的。
如下是一个简单的模块，写出来只是觉得很少有模块还带参数的...真有一天要带估计也得这么写吧。
module.exports = (width) => {
return {
area: () => width ** 2
};
};
模块读取机制
只取一部分，全部看这里。(All Together)[https://nodejs.org/dist/latest-v8.x/docs/api/modules.html#modules_all_together]。
require(X) from module at path Y
1. If X is a core module,
a. return the core module
b. STOP
2. If X begins with '/'
a. set Y to be the filesystem root
3. If X begins with './' or '/' or '../'
a. LOAD_AS_FILE(Y + X)
b. LOAD_AS_DIRECTORY(Y + X)
4. LOAD_NODE_MODULES(X, dirname(Y))
5. THROW "not found"
LOAD_AS_FILE(X)
1. If X is a file, load X as JavaScript text. STOP
2. If X.js is a file, load X.js as JavaScript text. STOP
3. If X.json is a file, parse X.json to a JavaScript Object. STOP
4. If X.node is a file, load X.node as binary addon. STOP
LOAD_INDEX(X)
1. If X/index.js is a file, load X/index.js as JavaScript text. STOP
2. If X/index.json is a file, parse X/index.json to a JavaScript object. STOP
3. If X/index.node is a file, load X/index.node as binary addon. STOP
LOAD_AS_DIRECTORY(X)
1. If X/package.json is a file,
a. Parse X/package.json, and look for "main" field.
b. let M = X + (json main field)
c. LOAD_AS_FILE(M)
d. LOAD_INDEX(M)
2. LOAD_INDEX(X)
LOAD_NODE_MODULES(X, START)
1. let DIRS=NODE_MODULES_PATHS(START)
2. for each DIR in DIRS:
a. LOAD_AS_FILE(DIR/X)
b. LOAD_AS_DIRECTORY(DIR/X)
NODE_MODULES_PATHS(START)
1. let PARTS = path split(START)
2. let I = count of PARTS - 1
3. let DIRS = []
4. while I >= 0,
a. if PARTS[I] = "node_modules" CONTINUE
b. DIR = path join(PARTS[0 .. I] + "node_modules")
c. DIRS = DIRS + DIR
d. let I = I - 1
5. return DIRS
缓存
模块在第一次被加载时是会被缓存的，所以在那之后的require行为都将返回同一个对象，模块内的代码也不会因为多次的require而被执行多次。
然而，模块的缓存是依据于他们的文件名的，而模块又可以根据调用模块的位置而解析为不同的文件名(后半句没懂)。所以不保证require('foo')总是返回同样的对象。
还有一个注意的事项，在一些不区分大小写的文件系统或操作系统，require('./foo')和require('./FOO')是返回不同的结果的，无论二者是否为相同的文件。
循环
考虑下面的情况。
a.js
console.log('a starting'); //3
exports.done = false; //4
const b = require('./b.js'); //5
console.log('in a, b.done = %j', b.done); //12
exports.done = true; //13
console.log('a done'); //14
b.js
console.log('b starting'); //6
exports.done = false; //7
const a = require('./a.js'); //8
console.log('in b, a.done = %j', a.done); //9
exports.done = true; //10
console.log('b done'); //11
main.js
console.log('main starting'); //1
const a = require('./a.js'); //2
const b = require('./b.js'); //15
console.log('in main, a.done=%j, b.done=%j', a.done, b.done); //16
以下是运行main.js的输出
main starting
a starting
b starting
in b, a.done = false
b done
in a, b.done = true
a done
in main, a.done=true, b.done=true
当 main.js被运行的时，先加载a.js，然后a.js又加载了b.js。此时，b.js想加载'a.js'。为了防止出现无限循环的清空，一个未完成的a.js副本会exports给b.js，然后完成b.js的加载，加载完的对象 exports给a.js。
整理一下运行的顺序。 (标柱)这里稍微提一下的是，15步因为缓存，所以没有再次执行b.js的代码。然后第一次运行b.js里中的const a = require('./a.js'); //8 虽然这里最开始是副本，但是等a.js加载完后，其中的变量a，也是加载完成后的状态了。
module对象
像之前(模块容器)提到，module并不是全局对象，而是每个模块内的对象。
module.children
- 数组
模块所需的对象
module.exports
- 对象
有些人希望导出的部分，是当前模块（类）的实例。
a.js
const EventEmitter = require('events');
module.exports = new EventEmitter();
setTimeout(() => {
module.exports.emit('ready');
}, 1000);
b.js
const a = require('./a');
a.on('ready', () => {
console.log('module a is ready');
});
module.exports必须被立即执行，不能放在任何的回调中。
exports 也只是一个普通的变量，默认情况下被赋值为 module.exports，其有作用域，也能被另外赋值。
附:模块语法
import
//导入默认的成员
import defaultMember from "module-name";
//导入整个模块，并将该模块在当前作用域命名为 `name`
import * as name from "module-name";
/* 以上二者的区别为，前者仅导入 default 关键字导出的成员。而后者导入的的是所有具名导出的成员，并凑成对象命名为 name*/
//导入模块的指定(`member`)成员(具名)
import { member } from "module-name";
//导入具名成员 member 并重命名为alias；
import { member as alias } from "module-name";
//导入多个具名成员
import { member1 , member2 } from "module-name";
//以下代码将MyModule，foo，bar插入到当前作用域。其中，MyModule是"my-module"模块中的export default 暴露的模块，而foo和bar则只是“my-module”代码中 export 暴露的对象中的 foo和 bar 属性。
import MyModule, { foo，bar} from "module-name";
//能够运行该模块的内容，但是不进行任何操作。
import "module-name";
export
export var myVar1 = ...;
export class MyClass {
...
}
export default 123;
const MY_CONST = ...;
function myFunc() {
...
}
export { MY_CONST, myFunc };
export { foo, bar } from 'src/other_module';
