NodeJS学习笔记之Module的简介

node.js模块系统

node.js有一个简单的模块加载系统。 在node.js中，文件和模块是一一对应的（每个文件被视为单独的模块）。

例如，考虑下面这个名为 foo.js 的文件：

const circle = require('./circle.js');
console.log(`the area of a circle of radius 4 is ${circle.area(4)}`);

在第一行， foo.js 加载与 foo.js 同一目录的模块 circle.js 。

circle.js 的内容如下：

const pi = math.pi;

exports.area = (r) => pi * r * r;

exports.circumference = (r) => 2* pi * r;

模块 circle.js 导出了函数 area() 和 circumference() 。 要将函数和对象添加到模块的根目录，可以将它们赋值到特殊 exports 对象上。

模块内部的变量一定是私有的，因为模块被node.js包裹在一个函数中（参见下面的模块包装器）。 在这个例子中，变量 pi 对于 circle.js 来说是私有变量。

如果你希望模块导出的是一个函数（如构造函数），或者是要导出完整的对象，而不是一次创建一个属性，则需要将其分配给 module.exports 而不是 exports 。

在下面的 bar.js 中，使用了 square 模块，它导出一个构造函数：

const square = require('./square.js');
var mysquare = square(2);
console.log(`the area of my square is ${mysquare.area()}`);

在 square.js 模块中定义一个 square 方法:

module.exports = (width) => {
  return {
    area: () => width * width;
  };
}

此外，模块系统在 require(“module”) 模块中实现。

『main』模块

当某个 module 直接从node.js运行时，它会将 require.main 设置该 module 。 你可以通过这个来测试这个 module 是被直接运行的还是被 require 的。

require.main === module

就拿文件 foo.js 来说，如果运行 node foo.js 这个属性就是 true 。运行 require('./foo.js') 就是 false 。

因为 module 提供了一个 filename （通常相当于 __filename ），因此可以通过检查 require.main.filename 来获取当前应用程序的入口点。

包管理器的一些提示

node.js的 require() 函数支持一些合理的目录结构。它让软件包管理器程序（如 dpkg ， rpm 和 npm ）可以从node.js模块中直接去构建本地的包而不需要修改。

下面我们给出一个可以正常工作的建议目录结构：

假设我们希望在 /usr/lib/node/<some-package>/<some-version> 中的文件夹来指定版本的包。

此外，包还可以相互依赖。 比如你想安装 foo 包，而这个包有可能需要安装指定版本的 bar 包。而 bar 包也很有可能依赖其他的包，并且在某些特殊情况下，这些依赖包甚至可能会产生循环依赖。

由于node.js会查找加载的所有模块的 realpath （即解析软链），然后再去node_modules文件夹中查找依赖的包，因此使用以下方案可以非常简单地解决此问题：

/usr/lib/node/foo/1.2.3/ - 包含 foo 包，版本是 1.2.3

/usr/lib/node/bar/4.3.2/ - 包含 foo 所依赖的 bar 包

/usr/lib/node/foo/1.2.3/node_modules/bar - 软链到 /usr/lib/node/bar/4.3.2/

/usr/lib/node/bar/4.3.2/node_modules/* - 软链到 bar 的依赖

因此，即使遇到循环依赖，或者是依赖冲突，每个模块都能加载到并使用自己所依赖指定版本的包。

当 foo 包中 require('bar') 时，它就可以软链到指定版本的 /usr/lib/node/foo/1.2.3/node_modules/bar 。然后，当 bar 包中的代码调用 require('quux') 时，它同样也可以软链到指定版本的 /usr/lib/node/bar/4.3.2/node_modules/quux 。

模块加载的全过程（重点，下面写的伪代码流程一定要记住）

要获取在调用 require() 将被加载的确切文件名，请使用 require.resolve() 函数。

以下是模块加载的全过程以及 require.resolve 的解析过程：

// 加载x模块
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 './' or '/' or '../'
  a. load_as_file(y + x)
  b. load_as_directory(y + x)
3. load_node_modules(x, dirname(y))
4. throw "not found"

// 加载x文件
// 加载过程：x -> x.js -> x.json -> x.node
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, load [x.json] as javascript text. stop
4. if [x.node] is a file, load [x.node] as javascript text. stop

// 加载入口文件
// 加载过程：x -> x/index.js -> x/index.json -> x/index.node
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, load [x/index.json] as javascript text. stop
3. if [x/index.node] if a file, load [x/index.node] as javascript text. 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)
 
// 加载node模块
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路径
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('foo') 将得到完全相同的对象。

对 require('foo') 的多次调用可能并不会多次执行该模块的代码。 这是一个重要的功能。 使用它，可以返回“partially done”对象，从而允许根据依赖关系一层一层地加载模块，即使这样做可能会导致循环依赖。

如果要让某个模块在每次被加载时都去执行代码，则需要 exports 一个函数，并调用该函数即可。

模块缓存注意事项

模块是基于其解析出来的文件名进行缓存。根据调用模块的路径，被调用的模块可能会解析出不同的文件名（从node_modules文件夹加载）。如果解析出来的是不同的文件，它不保证每次 require('foo') 总是返回相同的对象。

另外，在不区分大小写的文件系统或操作系统上，不同的解析文件名可以指向相同的文件，但缓存仍将它们视为不同的模块，并将重新加载该文件多次。 例如， require('./ foo') 和 require('./ foo') 返回两个不同的对象，而不管 ./foo 和 ./foo 是否是同一个文件。

核心模块

node.js有些模块被编译成二进制文件。 本文档中的其他部分将对这些模块进行更详细的描述。

核心模块在node.js的源码 lib/ 文件夹中。

如果核心模块的模块标识传递给 require() ，则它们总是优先加载。 例如，即使有一个自定义模块叫 http ，我们去执行 require('http') 也将始终返回内置的 http 模块，

循环引用

当循环引用 require() 时，返回模块可能并没有执行完成。

考虑这种情况：

a.js ：

console.log('a starting');
exports.done = false;
const b = require('./b.js');
console.log('in a, b.done = %j', b.done);
exports.done = true;
console.log('a done');

b.js ：

console.log('b starting');
exports.done = false;
const a = require('./a.js');
console.log('in b, a.done = %j', a.done);
exports.done = true;
console.log('b done');

app.js ：

console.log('main starting');
const a = require('./a.js');
const b = require('./b.js');
console.log('in main, a.done = %j, b.done = %j', a.done, b.done);

当 app.js 加载 a.js 时， a.js 依次加载 b.js . 此时， b.js 尝试加载 a.js . 为了防止无限循环，将 a.js 导出对象的未完成副本返回到 b.js 模块。 b.js 然后完成加载，并将其导出对象提供给 a.js 模块。

当 app.js 加载了这两个模块时，它们都已经完成。 因此，该程序的输出将是：

$ node app.js
main starting
a starting
b starting
in b, a.done = false
b done
in a, b.done = true
in main, a.done =true, b.done = true

模块包装器

在执行模块的代码之前，node.js将使用一个函数包装器来将模块内容包裹起来，如下所示：

(function (exports, require, module, __filename, __dirname) {
  // 你的模块代码
});

通过这样做，node.js实现了以下几点：

它将模块内部的*变量(定义为 var ， const 或 let )的作用域范围限定为模块内部而不是全局。

它有助于给模块内部提供一些实际上只属于该模块的全局变量，例如：

module 和 exports 对象用来帮助从模块内部导出一些值

变量 __filename 和 __dirname 是当前模块最终解析出来的文件名和文件夹路径

module 对象签名

object module {
  id: string, // 模块标识，为该模块文件在系统中的绝对路径
  exports: object, // 该模块的导出对象
  parent: object | undefined, // 引用该模块的父模块
  filename: string | null, // 最终解析的文件名称， 与__filename相同。
  loaded: boolean, // 该模块是否已经加载
  children: array, // 改模块的引用列表
  paths: array // 模块加载路径
}

require 函数签名

function require {
  [function], // 函数体
  resolve: function, // 根据模块标识解析模块，返回绝对路径
  main: undefined | object, // 应用的主(main)模块
  extensions: {'.js':function, '.json':function, '.node':function},
  cache: object // 模块缓存，以模块的绝对路径为key
}