通过源码解析 Node.js 启动时第一个执行的 js 文件：bootstrap_node.js

摘要：注很多以前的源码分析文章中，所写的第一个执行的文件代码为，但这个文件在中已被移除，并被拆解为了等其他下的文件，为正文作为第一段被执行的代码，它的历史使命免不了就是进行一些环境和全局变量的初始化工作。

大家可能会好奇，在 Node.js 启动后，第一个执行的 JavaScript 文件会是哪个？它具体又会干些什么事？

一步步来看，翻开 Node.js 的源码，不难看出，入口文件在 src/node_main.cc 中，主要任务为将参数传入 node::Start 函数：

// src/node_main.cc
// ...

int main(int argc, char *argv[]) {
  setvbuf(stderr, NULL, _IOLBF, 1024);
  return node::Start(argc, argv);
}

node::Start 函数定义于 src/node.cc 中，它进行了必要的初始化工作后，会调用 StartNodeInstance ：

// src/node.cc
// ...

int Start(int argc, char** argv) {
    // ...
    NodeInstanceData instance_data(NodeInstanceType::MAIN,
                                   uv_default_loop(),
                                   argc,
                                   const_cast(argv),
                                   exec_argc,
                                   exec_argv,
                                   use_debug_agent);
    StartNodeInstance(&instance_data);
}

而在 StartNodeInstance 函数中，又调用了 LoadEnvironment 函数，其中的 ExecuteString(env, MainSource(env), script_name); 步骤，便执行了第一个 JavaScript 文件代码：

// src/node.cc
// ...
void LoadEnvironment(Environment* env) { 
  // ...
  Local f_value = ExecuteString(env, MainSource(env), script_name);
  // ...
}

static void StartNodeInstance(void* arg) {
  // ...
  {
      Environment::AsyncCallbackScope callback_scope(env);
      LoadEnvironment(env);
  }
  // ...
}

// src/node_javascript.cc
// ...

Local MainSource(Environment* env) {
  return String::NewFromUtf8(
      env->isolate(),
      reinterpret_cast(internal_bootstrap_node_native),
      NewStringType::kNormal,
      sizeof(internal_bootstrap_node_native)).ToLocalChecked();
}

其中的 internal_bootstrap_node_native ，即为 lib/internal/bootstrap_node.js 中的代码。（注：很多以前的 Node.js 源码分析文章中，所写的第一个执行的 JavaScript 文件代码为 src/node.js ，但这个文件在 Node.js v5.10 中已被移除，并被拆解为了 lib/internal/bootstrap_node.js 等其他 lib/internal 下的文件，PR 为： https://github.com/nodejs/node/pull/5103 ）

作为第一段被执行的 JavaScript 代码，它的历史使命免不了就是进行一些环境和全局变量的初始化工作。代码的整体结构很简单，所有的初始化逻辑都被封装在了 startup 函数中：

// lib/internal/bootstrap_node.js
"use strict";

(function(process) {
  function startup() {
    // ...
  }
  // ...
  startup();
});

而在 startup 函数中，逻辑可以分为四块：

初始化全局 process 对象上的部分属性 / 行为

初始化全局的一些 timer 方法

初始化全局 console 等对象

开始执行用户执行指定的 JavaScript 代码

让我们一个个来解析。

在 Node.js 中，如果没有为 process 上的 uncaughtException 事件注册监听器，那么该事件触发时，将会导致进程退出，这个行为便是在 startup 函数里添加的：

// lib/internal/bootstrap_node.js
"use strict";

(function(process) {
  function startup() {
    setupProcessFatal();
  }
  // ...

  function setupProcessFatal() {

    process._fatalException = function(er) {
      var caught;
      // ...
      if (!caught)
        caught = process.emit("uncaughtException", er);

      if (!caught) {
        try {
          if (!process._exiting) {
            process._exiting = true;
            process.emit("exit", 1);
          }
        } catch (er) {
        }
      } 
      // ...
      return caught;
    };
  }
});

逻辑十分直白，使用到了 EventEmitter#emit 的返回值来判断该事件上是否有注册过的监听器，并最终调用 c++ 的 exit() 函数退出进程：

// src/node.cc
// ...

void FatalException(Isolate* isolate,
                    Local error,
                    Local message) {
  // ...
  Local caught =
      fatal_exception_function->Call(process_object, 1, &error);
      
  // ...
  if (false == caught->BooleanValue()) {
    ReportException(env, error, message);
    exit(1);
  }
}

具体来说，这些参数是：--no-warnings，--no-deprecation，--trace-deprecation 和 --throw-deprecation。这些参数的有无信息，会先被挂载在 process 对象上：

// src/node.cc
// ...

  if (no_deprecation) {
    READONLY_PROPERTY(process, "noDeprecation", True(env->isolate()));
  }

  if (no_process_warnings) {
    READONLY_PROPERTY(process, "noProcessWarnings", True(env->isolate()));
  }

  if (trace_warnings) {
    READONLY_PROPERTY(process, "traceProcessWarnings", True(env->isolate()));
  }

  if (throw_deprecation) {
    READONLY_PROPERTY(process, "throwDeprecation", True(env->isolate()));
  }

然后根据这些信息，控制行为：

// lib/internal/bootstrap_node.js
"use strict";

(function(process) {
  function startup() {
    // ...
    NativeModule.require("internal/process/warning").setup();
  }
  // ...
  startup();
});

// lib/internal/process/warning.js
"use strict";

const traceWarnings = process.traceProcessWarnings;
const noDeprecation = process.noDeprecation;
const traceDeprecation = process.traceDeprecation;
const throwDeprecation = process.throwDeprecation;
const prefix = `(${process.release.name}:${process.pid}) `;

exports.setup = setupProcessWarnings;

function setupProcessWarnings() {
  if (!process.noProcessWarnings) {
    process.on("warning", (warning) => {
      if (!(warning instanceof Error)) return;
      const isDeprecation = warning.name === "DeprecationWarning";
      if (isDeprecation && noDeprecation) return;
      const trace = traceWarnings || (isDeprecation && traceDeprecation);
      if (trace && warning.stack) {
        console.error(`${prefix}${warning.stack}`);
      } else {
        var toString = warning.toString;
        if (typeof toString !== "function")
          toString = Error.prototype.toString;
        console.error(`${prefix}${toString.apply(warning)}`);
      }
    });
  }
  // ...
}

具体行为的话，文档中已经有详细说明，逻辑总结来说，就是按需将警告打印到控制台，或者按需抛出特定的异常。其中 NativeModule 对象为 Node.js 在当前的函数体的局部作用域内，实现的一个最小可用的模块加载器，具有缓存等基本功能。

通常为 tty.ReadStream 类和 tty.WriteStream 类的实例：

// lib/internal/bootstrap_node.js
"use strict";

(function(process) {
  function startup() {
    // ...
    NativeModule.require("internal/process/stdio").setup();
  }
  // ...
  startup();
});

// lib/internal/process/stdio.js
// ...

function setupStdio() {
  var stdin, stdout, stderr;

  process.__defineGetter__("stdout", function() {
    if (stdout) return stdout;
    stdout = createWritableStdioStream(1);
    // ...
    return stdout
  }

  process.__defineGetter__("stderr", function() {
    if (stderr) return stderr;
    stderr = createWritableStdioStream(2);
    // ...
    return stderr;
  });

  process.__defineGetter__("stdin", function() {
    if (stdin) return stdin;

    var tty_wrap = process.binding("tty_wrap");
    var fd = 0;

    switch (tty_wrap.guessHandleType(fd)) {
      case "TTY":
        var tty = require("tty");
        stdin = new tty.ReadStream(fd, {
          highWaterMark: 0,
          readable: true,
          writable: false
        });
        break;
      // ...
    }
    return stdin;
  }
}

function createWritableStdioStream(fd) {
  var stream;
  var tty_wrap = process.binding("tty_wrap");

  // Note stream._type is used for test-module-load-list.js

  switch (tty_wrap.guessHandleType(fd)) {
    case "TTY":
      var tty = require("tty");
      stream = new tty.WriteStream(fd);
      stream._type = "tty";
      break;
    // ...    
  }
  // ...
}

具体的做法便是将注册的回调推进队列中，等待事件循环的下一次 Tick ，一个个取出执行：

// lib/internal/bootstrap_node.js
"use strict";

(function(process) {
  function startup() {
    // ...
    NativeModule.require("internal/process/next_tick").setup();
  }
  // ...
  startup();
});

// lib/internal/process/next_tick.js
"use strict";

exports.setup = setupNextTick;

function setupNextTick() {
  var nextTickQueue = [];
  // ...
  var kIndex = 0;
  var kLength = 1;

  process.nextTick = nextTick;
  process._tickCallback = _tickCallback;

  function _tickCallback() {
    var callback, args, tock;

    do {
      while (tickInfo[kIndex] < tickInfo[kLength]) {
        tock = nextTickQueue[tickInfo[kIndex]++];
        callback = tock.callback;
        args = tock.args;
        _combinedTickCallback(args, callback);
        if (1e4 < tickInfo[kIndex])
          tickDone();
      }
      tickDone();
    } while (tickInfo[kLength] !== 0);
  }

  function nextTick(callback) {
    if (typeof callback !== "function")
      throw new TypeError("callback is not a function");
    if (process._exiting)
      return;

    var args;
    if (arguments.length > 1) {
      args = new Array(arguments.length - 1);
      for (var i = 1; i < arguments.length; i++)
        args[i - 1] = arguments[i];
    }

    nextTickQueue.push(new TickObject(callback, args));
    tickInfo[kLength]++;
  }
}
// ...

// lib/internal/bootstrap_node.js
"use strict";

(function(process) {
  function startup() {
    // ...
    _process.setup_hrtime();
    _process.setupKillAndExit();
  }
  // ...
  startup();
});

这些功能的核心实现也重度依赖于 c++ 函数：

hrtime 方法依赖于 libuv 提供的 uv_hrtime() 函数

kill 方法依赖于 libuv 提供的 uv_kill(pid, sig) 函数

exit 方法依赖于 c++ 提供的 exit(code) 函数

这些初始化都干的十分简单，直接赋值：

// lib/internal/bootstrap_node.js
"use strict";

(function(process) {
  function startup() {
    // ...
    setupGlobalVariables();
    if (!process._noBrowserGlobals) {
      setupGlobalTimeouts();
      setupGlobalConsole();
    }
    
    function setupGlobalVariables() {
      global.process = process;
      // ...
      global.Buffer = NativeModule.require("buffer").Buffer;
      process.domain = null;
      process._exiting = false;
    }
    
    function setupGlobalTimeouts() {
      const timers = NativeModule.require("timers");
      global.clearImmediate = timers.clearImmediate;
      global.clearInterval = timers.clearInterval;
      global.clearTimeout = timers.clearTimeout;
      global.setImmediate = timers.setImmediate;
      global.setInterval = timers.setInterval;
      global.setTimeout = timers.setTimeout;
    }

    function setupGlobalConsole() {
      global.__defineGetter__("console", function() {
        return NativeModule.require("console");
      });
    }
  }
  // ...
  startup();
});

值得注意的一点是，由于 console 是通过 __defineGetter__ 赋值给 global 对象的，所以在严格模式下给它赋值将会抛出异常，而非严格模式下，赋值将被忽略。

这一部分的逻辑已经在之前的文章中有所阐述，这边就不再重复说明啦。

还是再次总结下:

lib/internal/bootstrap_node.js 中的代码 为 Node.js 执行后第一段被执行的 JavaScript 代码，从 src/node.cc 中的 node::LoadEnvironment 被调用

lib/internal/bootstrap_node.js 主要进行了一些初始化工作：

初始化全局 process 对象上的部分属性 / 行为

添加接收到 uncaughtException 事件时的默认行为

根据 Node.js 启动时参数，调整 warning 事件的行为

添加上 stdin，stdout 和 stderr 属性

添加上 nextTick，hrtime，exit 方法

初始化全局的一些 timer 方法

初始化全局 console 等对象

开始执行用户执行指定的 JavaScript 代码

https://github.com/nodejs/node/blob/master/src/node.cc

https://github.com/nodejs/node/blob/master/src/node_javascript.cc

https://github.com/nodejs/node/blob/master/lib/internal/process.js

https://github.com/nodejs/node/blob/master/lib/internal/process/next_tick.js

https://github.com/nodejs/node/blob/master/lib/internal/process/stdio.js

https://github.com/nodejs/node/blob/master/lib/internal/process/warning.js

https://github.com/nodejs/node/blob/master/lib/internal/bootstrap_node.js