Node.js的模块机制

本文参考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';

参考:ECMAScript 6 modules: the final syntax