深聊Nodejs模块化

本文只讨论 CommonJS 规范，不涉及 ESM

我们知道 JavaScript 这门语言诞生之初主要是为了完成网页上表单的一些规则校验以及动画制作，所以布兰登.艾奇（Brendan Eich）只花了一周多就把 JavaScript 设计出来了。可以说 JavaScript 从出生开始就带着许多缺陷和缺点，这一点一直被其他语言的编程者所嘲笑。随着 BS 开发模式渐渐地火了起来，JavaScript 所要承担的责任也越来越大，ECMA 接手标准化之后也渐渐的开始完善了起来。

在 ES 6 之前，JavaScript 一直是没有自己的模块化机制的，JavaScript 文件之间无法相互引用，只能依赖脚本的加载顺序以及全局变量来确定变量的传递顺序和传递方式。而 script 标签太多会导致文件之间依赖关系混乱，全局变量太多也会导致数据流相当紊乱，命名冲突和内存泄漏也会更加频繁的出现。直到 ES 6 之后，JavaScript 开始有了自己的模块化机制，不用再依赖 requirejs、seajs 等插件来实现模块化了。

在 Nodejs 出现之前，服务端 JavaScript 基本上处于一片荒芜的境况，而当时也没有出现 ES 6 的模块化规范（Nodejs 最早从 V8.5 开始支持 ESM 规范：Node V8.5 更新日志），所以 Nodejs 采用了当时比较先进的一种模块化规范来实现服务端 JavaScript 的模块化机制，它就是 CommonJS，有时也简称为 CJS。

这篇文章主要讲解 CommonJS 在 Nodejs 中的实现。

一、CommonJS 规范

在 Nodejs 采用 CommonJS 规范之前，还存在以下缺点：

• 没有模块系统
• 标准库很少
• 没有标准接口
• 缺乏包管理系统

这几点问题的存在导致 Nodejs 始终难以构建大型的项目，生态环境也是十分的贫乏，所以这些问题都是亟待解决的。

CommonJS 的提出，主要是为了弥补当前 JavaScript 没有模块化标准的缺陷，以达到像 Java、Python、Ruby 那样能够构建大型应用的阶段，而不是仅仅作为一门脚本语言。Nodejs 能够拥有今天这样繁荣的生态系统，CommonJS 功不可没。

1.1 CommonJS 的模块化规范

CommonJS 对模块的定义十分简单，主要分为模块引用、模块定义和模块标识三个部分。下面进行简单介绍：

1.1.1、模块引用

示例如下：

const fs = require('fs')

在 CommonJS 规范中，存在一个 require “全局”方法，它接受一个标识，然后把标识对应的模块的 API 引入到当前模块作用域中。

1.1.2、模块定义

我们已经知道了如何引入一个 Nodejs 模块，但是我们应该如何定义一个 Nodejs 模块呢？在 Nodejs 上下文环境中提供了一个 module 对象和一个 exports 对象，module 代表当前模块，exports 是当前模块的一个属性，代表要导出的一些 API。在 Nodejs 中，一个文件就是一个模块，把方法或者变量作为属性挂载在 exports 对象上即可将其作为模块的一部分进行导出。

// add.js
exports.add = function(a, b) {
   
    return a + b
}

在另一个文件中，我们就可以通过 require 引入之前定义的这个模块：

const {
    add } = require('./add.js')

add(1, 2) // print 3

1.1.3、模块标识

模块标识就是传递给 require 函数的参数，在 Nodejs 中就是模块的 id。它必须是符合小驼峰命名的字符串，或者是以.、…开头的相对路径，或者绝对路径，可以不带后缀名。

模块的定义十分简单，接口也很简洁。它的意义在于将类聚的方法和变量等限定在私有的作用于域中，同时支持引入和导出功能以顺畅的连接上下游依赖。

CommonJS 这套模块导出和引入的机制使得用户完全不必考虑变量污染。

以上只是对于 CommonJS 规范的简单介绍，更多具体的内容可以参考：CommonJS规范

二、Nodejs 的模块化实现

Nodejs 在实现中并没有完全按照规范实现，而是对模块规范进行了一定的取舍，同时也增加了一些自身需要的特性。接下来我们会探究一下 Nodejs 是如何实现 CommonJS 规范的。

在 Nodejs 中引入模块会经过以下三个步骤：

• 路径分析
• 文件定位
• 编译执行

在了解具体的内容之前我们先了解两个概念：

• 核心模块：Nodejs 提供的内置模块，比如 fs、url、http 等
• 文件模块：用户自己编写的模块，比如 Koa、Express 等

核心模块在 Nodejs 源代码的编译过程中已经编译进了二进制文件，Nodejs 启动时会被直接加载到内存中，所以在我们引入这些模块的时候就省去了文件定位、编译执行这两个步骤，加载速度比文件模块要快很多。

文件模块是在运行的时候动态加载，需要走一套完整的流程：路径分析、文件定位、编译执行等，所以文件模块的加载速度比核心模块要慢。

2.1 优先从缓存加载

在讲解具体的加载步骤之前，我们应当知晓的一点是，Nodejs 对于已经加载过一边的模块会进行缓存，模块的内容会被缓存到内存当中，如果下次加载了同一个模块的话，就会从内存中直接取出来，这样就省去了第二次路径分析、文件定位、加载执行的过程，大大提高了加载速度。无论是核心模块还是文件模块，require() 对同一文件的第二次加载都一律会采用缓存优先的方式，这是第一优先级的。但是核心模块的缓存检查优先于文件模块的缓存检查。

我们在 Nodejs 文件中所使用的 require 函数，实际上就是在 Nodejs 项目中的 lib/internal/modules/cjs/loader.js 所定义的 Module.prototype.require 函数，只不过在后面的 makeRequireFunction 函数中还会进行一层封装，Module.prototype.require 源码如下：

// Loads a module at the given file path. Returns that module's
// `exports` property.
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--;
    }
};

可以看到它最终使用了 Module._load 方法来加载我们的标识符所指定的模块，找到 Module._load：

Module._cache = Object.create(null);
// 这里先定义了一个缓存的对象

// ... ...

// Check the cache for the requested file.
// 1. If a module already exists in the cache: return its exports object.
// 2. If the module is native: call
//    `NativeModule.prototype.compileForPublicLoader()` and return the exports.
// 3. Otherwise, create a new module for the file and save it to the cache.
//    Then have it load  the file contents before returning its exports
//    object.
Module._load = function(request, parent, isMain) {
   
    let relResolveCacheIdentifier;
    if (parent) {
   
        debug('Module._load REQUEST %s parent: %s', request, parent.id);
        // Fast path for (lazy loaded) modules in the same directory. The indirect
        // caching is required to allow cache invalidation without changing the old
        // cache key names.
        relResolveCacheIdentifier = `${
     parent.path}\x00${
     request}`;
        const filename = relativeResolveCache[relResolveCacheIdentifier];
        if (filename !== undefined) {
   
            const cachedModule = Module._cache[filename];
            if (cachedModule !== undefined) {
   
                updateChildren(parent, cachedModule, true);
                return cachedModule.exports;
            }
            delete relativeResolveCache[relResolveCacheIdentifier];
        }
    }

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

    const cachedModule = Module._cache[filename];
    if (cachedModule !== undefined) {
   
        updateChildren(parent, cachedModule, true);
        return cachedModule.exports;
    }

    const mod = loadNativeModule(filename, re