Node 中如何引入一个模块及其细节

本文收录于 GitHub 山月行博客: shfshanyue/blog，内含我在实际工做中碰到的问题、关于业务的思考及在全栈方向上的学习

• 前端工程化系列
• Node进阶系列

在 node 环境中，有两个内置的全局变量无需引入便可直接使用，而且无处不见，它们构成了 nodejs 的模块体系: module 与 require。如下是一个简单的示例

const fs = require('fs')

const add = (x, y) => x + y

module.exports = add

虽然它们在日常使用中仅仅是引入与导出模块，但稍稍深刻，即可见乾坤之大。在业界可用它们作一些比较 trick 的事情，虽然我不大建议使用这些黑科技，但稍微了解仍是颇有必要。

1. 如何在不重启应用时热加载模块？如 require 一个 json 文件时会产生缓存，可是重写文件时如何 watch
2. 如何经过不侵入代码进行打印日志
3. 循环引用会产生什么问题？

module wrapper

当咱们使用 node 中写一个模块时，实际上该模块被一个函数包裹，以下所示:

(function(exports, require, module, __filename, __dirname) {
  // 全部的模块代码都被包裹在这个函数中
  const fs = require('fs')

  const add = (x, y) => x + y

  module.exports = add
});

所以在一个模块中自动会注入如下变量：

• exports
• require
• module
• __filename
• __dirname

module

调试最好的办法就是打印，咱们想知道 module 是何方神圣，那就把它打印出来！

const fs = require('fs')

const add = (x, y) => x + y

module.exports = add

console.log(module)

• module.id: 若是是 . 表明是入口模块，不然是模块所在的文件名，可见以下的 koa
• module.exports: 模块的导出

module.exports 与 exports

module.exports 与 exports 有什么关系？

从如下源码中能够看到 module wrapper 的调用方 module._compile 是如何注入内置变量的，所以根据源码很容易理解一个模块中的变量：

• exports: 其实是 module.exports 的引用
• require: 大多状况下是 Module.prototype.require
• module
• __filename
• __dirname: path.dirname(__filename)

// <node_internals>/internal/modules/cjs/loader.js:1138

Module.prototype._compile = function(content, filename) {
  // ...
  const dirname = path.dirname(filename);
  const require = makeRequireFunction(this, redirects);
  let result;

  // 从中能够看出：exports = module.exports
  const exports = this.exports;
  const thisValue = exports;
  const module = this;
  if (requireDepth === 0) statCache = new Map();
  if (inspectorWrapper) {
    result = inspectorWrapper(compiledWrapper, thisValue, exports,
                              require, module, filename, dirname);
  } else {
    result = compiledWrapper.call(thisValue, exports, require, module,
                                  filename, dirname);
  }
  // ...
}

require

经过 node 的 REPL 控制台，或者在 VSCode 中输出 require 进行调试，能够发现 require 是一个极其复杂的对象

从以上 module wrapper 的源码中也能够看出 require 由 makeRequireFunction 函数生成，以下

// <node_internals>/internal/modules/cjs/helpers.js:33

function makeRequireFunction(mod, redirects) {
  const Module = mod.constructor;

  let require;
  if (redirects) {
    // ...
  } else {
    // require 其实是 Module.prototype.require
    require = function require(path) {
      return mod.require(path);
    };
  }

  function resolve(request, options) { // ... }

  require.resolve = resolve;

  function paths(request) {
    validateString(request, 'request');
    return Module._resolveLookupPaths(request, mod);
  }

  resolve.paths = paths;

  require.main = process.mainModule;

  // Enable support to add extra extension types.
  require.extensions = Module._extensions;

  require.cache = Module._cache;

  return require;
}

关于 require 更详细的信息能够去参考官方文档: Node API: require

require(id)

require 函数被用做引入一个模块，也是日常最多见最经常使用到的函数

// <node_internals>/internal/modules/cjs/loader.js:1019

Module.prototype.require = function(id) {
  validateString(id, 'id');
  if (id === '') {
    throw new ERR_INVALID_ARG_VALUE('id', id,
                                    'must be a non-empty string');
  }
  requireDepth++;
  try {
    return Module._load(id, this, /* isMain */ false);
  } finally {
    requireDepth--;
  }
}

而 require 引入一个模块时，实际上经过 Module._load 载入，大体的总结以下：

1. 若是 Module._cache 命中模块缓存，则直接取出 module.exports，加载结束
2. 若是是 NativeModule，则 loadNativeModule 加载模块，如 fs、http、path 等模块，加载结束
3. 不然，使用 Module.load 加载模块，固然这个步骤也很长，下一章节再细讲

// <node_internals>/internal/modules/cjs/loader.js:879

Module._load = function(request, parent, isMain) {
  let relResolveCacheIdentifier;
  if (parent) {
    // ...
  }

  const filename = Module._resolveFilename(request, parent, isMain);

  const cachedModule = Module._cache[filename];

  // 若是命中缓存，直接取缓存
  if (cachedModule !== undefined) {
    updateChildren(parent, cachedModule, true);
    return cachedModule.exports;
  }

  // 若是是 NativeModule，加载它
  const mod = loadNativeModule(filename, request);
  if (mod && mod.canBeRequiredByUsers) return mod.exports;

  // Don't call updateChildren(), Module constructor already does.
  const module = new Module(filename, parent);

  if (isMain) {
    process.mainModule = module;
    module.id = '.';
  }

  Module._cache[filename] = module;
  if (parent !== undefined) { // ... }

  let threw = true;
  try {
    if (enableSourceMaps) {
      try {
        // 若是不是 NativeModule，加载它
        module.load(filename);
      } catch (err) {
        rekeySourceMap(Module._cache[filename], err);
        throw err; /* node-do-not-add-exception-line */
      }
    } else {
      module.load(filename);
    }
    threw = false;
  } finally {
    // ...
  }

  return module.exports;
};

require.cache

当代码执行 require(lib) 时，会执行 lib 模块中的内容，并做为一份缓存，下次引用时再也不执行模块中内容。

这里的缓存指的就是 require.cache，也就是上一段指的 Module._cache

// <node_internals>/internal/modules/cjs/loader.js:899

require.cache = Module._cache;

这里有个小测试:

有两个文件: index.js 与 utils.js。 utils.js 中有一个打印操做，当 index.js 引用 utils.js 屡次时， utils.js 中的打印操做会执行几回。代码示例以下

index.js

// index.js

// 此处引用两次
require('./utils')
require('./utils')

utils.js

// utils.js
console.log('被执行了一次')

答案是只执行了一次，所以 require.cache，在 index.js 末尾打印 require，此时会发现一个模块缓存

// index.js

require('./utils')
require('./utils')

console.log(require)

那回到本章刚开始的问题：

如何不重启应用热加载模块呢？

答：删掉 Module._cache，但同时会引起问题，如这种 一行 delete require.cache 引起的内存泄漏血案

因此说嘛，这种黑魔法大幅修改核心代码的东西开发环境玩一玩就能够了，千万不要跑到生产环境中去，毕竟黑魔法是不可控的。

总结

1. 模块中执行时会被 module wrapper 包裹，并注入全局变量 require 及 module 等
2. module.exports 与 exports 的关系其实是 exports = module.exports
3. require 其实是 module.require
4. require.cache 会保证模块不会被执行屡次
5. 不要使用 delete require.cache 这种黑魔法

关注我

本文收录于 GitHub 山月行博客: shfshanyue/blog，内含我在实际工做中碰到的问题、关于业务的思考及在全栈方向上的学习

• 前端工程化系列
• Node进阶系列

欢迎关注公众号【全栈成长之路】，定时推送 Node 原创及全栈成长文章

<figure> <img width="240" src="https://shanyue.tech/qrcode.jpg" alt="欢迎关注"> <figcaption>欢迎关注全栈成长之路</figcaption></figure>