Node.js 启动流程：从 C++ `node::Start()` 到用户代码执行

各位编程爱好者，大家好！

今天我们将深入探讨 Node.js 的启动流程，这是一个既复杂又迷人的主题。从我们在命令行敲下node app.js的那一刻起，到我们的 JavaScript 代码真正开始执行，这背后经历了 C++、V8 引擎、libuv 事件循环以及 Node.js 核心模块的协同工作。理解这个过程，不仅能帮助我们更好地调试和优化 Node.js 应用，还能深化我们对整个运行时环境的认识。

我们将从 Node.js 的 C++ 启动入口node::Start()开始，逐步揭示 V8 引擎的初始化、libuv 事件循环的建立、Node.js 环境对象的构建、内置模块的加载，直至最终用户 JavaScript 代码的执行。

Node.js 启动的宏观视角

Node.js 的核心架构可以概括为以下几个主要组件：

• V8 JavaScript 引擎：负责解析、编译和执行 JavaScript 代码。
• libuv 库：提供跨平台的异步 I/O 和事件循环能力。它抽象了操作系统底层的非阻塞 I/O 操作，使得 Node.js 能够高效处理并发连接。
• C++ 核心模块：实现了 Node.js 的大部分底层功能，例如文件系统、网络、HTTP 等，并通过 V8 的 FFI（Foreign Function Interface）或 C++ bindings 暴露给 JavaScript。
• JavaScript 核心模块：位于lib/目录下，由纯 JavaScript 实现，构建在 C++ 核心模块之上，提供了更高级别的 API。

当一个 Node.js 进程启动时，它首先是一个标准的 C++ 应用程序。这个 C++ 应用程序负责初始化 V8 引擎、设置事件循环、加载 Node.js 的内置模块，并最终将控制权交给 JavaScript。

整个启动流程可以概括为：

1. C++ 初始化：解析命令行参数，初始化 V8 和 libuv。
2. 环境构建：创建 Node.js 运行时环境对象 (node::Environment) 和 V8 上下文 (v8::Context)。
3. 内置模块加载：将 Node.js 的 C++ 内置绑定和 JavaScript 内置模块 (internal/*) 注入到 V8 上下文中。
4. JavaScript 引导：执行 Node.js 的 JavaScript 引导代码 (internal/bootstrap/node.js)，设置process、global等全局对象。
5. 用户代码执行：加载并执行用户提供的 JavaScript 入口文件。
6. 事件循环：进入 libuv 事件循环，处理异步事件。

接下来，我们将逐一深入这些步骤。

C++ 世界的入口：node::Start()

Node.js 应用程序的生命周期始于 C++ 端的main函数。在src/node_main.cc文件中，我们可以找到这个入口点。它的主要职责是解析命令行参数，设置 V8 和 Node.js 的全局配置，然后调用node::Start()函数。

// src/node_main.cc // ... 其他包含和定义 int main(int argc, char* argv[]) { // 1. 设置 V8 的标志，例如垃圾回收、调试等 // v8::V8::SetFlagsFromCommandLine(&argc, argv, true); // 2. 将命令行参数传递给 Node.js 的启动函数 std::vector<std::string> args(argv, argv + argc); std::vector<std::string> exec_args; // 存储 Node.js 运行时参数，例如 --inspect // ParseArgs 是一个辅助函数，用于区分 Node.js 运行时参数和用户脚本参数 // node::ParseArgs(&args, &exec_args); // 3. 调用 node::Start() 函数 int exit_code = node::Start(args, exec_args); return exit_code; }

node::Start()函数（位于src/node.cc）是 Node.js 启动流程中至关重要的一环。它负责：

1. 初始化 V8 平台：为 V8 引擎提供必要的服务，如任务调度、内存分配。
2. 创建 V8 实例：创建v8::Isolate，这是 V8 引擎的一个独立运行实例。
3. 创建 Node.js 环境：构建node::Environment对象，它封装了 V8 实例、事件循环、上下文等 Node.js 运行所需的所有状态。
4. 加载内置模块：将 Node.js 的 C++ 绑定和 JavaScript 内置模块加载到环境中。
5. 执行 JavaScript 引导代码：运行internal/bootstrap/node.js。
6. 执行用户代码：加载并执行用户提供的 JavaScript 文件。
7. 进入事件循环：启动 libuv 事件循环，使 Node.js 能够处理异步事件。

让我们逐步拆解node::Start()的内部细节。

// src/node.cc namespace node { // ... 其他辅助函数和定义 int Start(const std::vector<std::string>& args, const std::vector<std::string>& exec_args) { // 1. 初始化 V8 平台 // Node.js 提供了一个 V8::Platform 的实现，用于处理 V8 的异步任务、计时器等 std::unique_ptr<v8::Platform> platform = V8Platform::Create(); v8::V8::InitializePlatform(platform.get()); v8::V8::Initialize(); // 初始化 V8 引擎 // 2. 创建 V8 Isolate // Isolate 是 V8 的一个独立运行实例，拥有自己的堆和垃圾回收器 std::unique_ptr<v8::Isolate> isolate = NewIsolate(); if (!isolate) { // 错误处理 return 1; } // 3. 设置 Isolate 的委托（Delegate） // 用于处理 Promise 拒绝、错误捕获等 SetIsolateDelegate(isolate.get(), platform.get()); // 4. 初始化 UV 循环 // Node.js 的事件循环是由 libuv 提供的 uv_loop_t default_loop; int err = uv_loop_init(&default_loop); if (err) { // 错误处理 return 1; } // 5. 创建 Node.js 环境 // Environment 是 Node.js 运行时的核心对象，封装了 Isolate, Context, uv_loop_t 等 std::unique_ptr<Environment> env = CreateEnvironment(isolate.get(), &default_loop, args, exec_args); if (!env) { // 错误处理 return 1; } // 6. 加载内置模块 // 这会将 Node.js 的 C++ 绑定和 JavaScript 内置模块注册到环境中 loader::InitializeBuiltinModules(env.get()); // 7. 执行 Environment 的初始化，包括运行 JavaScript 引导代码 // 这会执行 internal/bootstrap/node.js LoadEnvironment(env.get()); // 8. 启动事件循环，开始处理异步操作 int exit_code = uv_run(&default_loop, UV_RUN_DEFAULT); // 9. 关闭事件循环和清理资源 uv_loop_close(&default_loop); // ... 清理 V8 资源 return exit_code; } } // namespace node

从上述代码中，我们可以看到node::Start()串联起了 V8 引擎的初始化、libuv 事件循环的建立以及 Node.js 运行时环境的创建。

V8 引擎的初始化与配置

V8 是 Node.js 的 JavaScript 执行引擎。在 Node.js 启动之初，必须对其进行初始化和配置。这涉及到v8::Platform、v8::Isolate和v8::ArrayBuffer::Allocator的创建。

v8::Platform

v8::Platform是 V8 引擎与宿主环境（Node.js 在此）之间的一个接口。它允许宿主环境为 V8 提供一些平台相关的服务，例如：

• 任务调度：V8 内部会有一些后台任务（如垃圾回收的并发标记），需要平台来调度执行。
• 线程池：提供执行这些任务的线程。
• 计时器：用于 V8 内部的定时操作。
• 跟踪：用于性能分析和调试。

Node.js 实现了自己的V8Platform类（在src/node_platform.cc中），它利用 libuv 来调度任务和管理线程池。

// src/node.cc (片段) // ... std::unique_ptr<v8::Platform> platform = V8Platform::Create(); v8::V8::InitializePlatform(platform.get()); // 将 Node.js 的平台实现告知 V8 v8::V8::Initialize(); // 初始化 V8 引擎 // ...

v8::Isolate

v8::Isolate是 V8 引擎的一个独立运行实例。每个Isolate都拥有自己的堆内存、垃圾回收器和全局对象。这意味着在同一个进程中可以运行多个Isolate，它们之间是完全隔离的，互不影响。Node.js 的主线程通常只使用一个Isolate，但在 Worker Threads 等场景下会创建新的Isolate。

node::NewIsolate()函数负责创建并配置这个Isolate。

// src/node.cc (片段) std::unique_ptr<v8::Isolate> NewIsolate() { // 1. 创建 ArrayBuffer Allocator // 用于 V8 内部的 ArrayBuffer 内存分配，Node.js 使用自己的实现来优化内存使用 std::unique_ptr<v8::ArrayBuffer::Allocator> allocator = ArrayBufferAllocator::Create(); // 2. 创建 Isolate::CreateParams // 包含创建 Isolate 所需的所有参数 v8::Isolate::CreateParams create_params; create_params.array_buffer_allocator = allocator.get(); // ... 其他参数设置，例如快照数据 // 3. 创建 Isolate v8::Isolate* isolate = v8::Isolate::New(create_params); if (!isolate) { return nullptr; } // 4. 释放 allocator 的所有权，由 Isolate 管理 // 注意：Node.js 通常会把 allocator 绑定到 Environment 对象，并由其管理生命周期 // 这里简化了，实际情况更复杂 create_params.array_buffer_allocator.release(); // 5. 设置 Isolate 的数据槽，用于存储自定义数据 // 例如，可以将 Environment 指针存储在这里，方便在回调中获取 // isolate->SetData(kNodeContextEmbedderDataIndex, env_ptr); return std::unique_ptr<v8::Isolate>(isolate); }

v8::SetIsolateDelegate()

这个函数用于设置 V8Isolate的一些回调，例如当 Promise 被拒绝但没有处理时，或者当发生未捕获的异常时，V8 会通过这些回调通知宿主环境。Node.js 会利用这些回调来实现process.on('unhandledRejection')和process.on('uncaughtException')等机制。

// src/node.cc (片段) // ... void SetIsolateDelegate(v8::Isolate* isolate, v8::Platform* platform) { // 设置各种事件处理器，例如 Promise 拒绝处理、消息处理等 isolate->SetHostInitializeImportMetaObjectCallback( HostInitializeImportMetaObject); isolate->SetHostImportModuleDynamicallyCallback(HostImportModuleDynamically); isolate->SetPromiseRejectCallback(PromiseRejectCallback); // ... 其他回调设置 } // ...

通过这些步骤，V8 引擎就被成功初始化并准备就绪，可以开始执行 JavaScript 代码了。

Node.js 运行时环境的核心：node::Environment

node::Environment是 Node.js 启动流程中的核心概念。它是一个 C++ 对象，封装了一个 Node.js 实例运行所需的所有状态，包括：

• *`v8::Isolateisolate_`**：对应的 V8 实例。
• v8::Local<v8::Context> context_：对应的 V8 JavaScript 上下文。
• *`uv_loop_teventloop`**：对应的 libuv 事件循环。
• std::vector<std::string> args_：命令行参数。
• std::vector<std::string> exec_args_：Node.js 运行时参数。
• 各种内部模块、绑定、回调函数等。

node::CreateEnvironment()函数负责创建并初始化这个Environment对象。

// src/node.cc (片段) // ... std::unique_ptr<Environment> CreateEnvironment( v8::Isolate* isolate, uv_loop_t* event_loop, const std::vector<std::string>& args, const std::vector<std::string>& exec_args) { // 1. 创建 V8 Context // Context 是 JavaScript 执行的“沙箱”，拥有自己的全局对象 v8::Local<v8::Context> context = v8::Context::New(isolate); // 实际创建过程更复杂，可能涉及快照 // 2. 进入 Context v8::Context::Scope context_scope(context); // 3. 创建 Environment 实例 Environment* env = new Environment(context, isolate, event_loop, args, exec_args); // 4. 初始化 Environment // 这会设置 Isolate 的一些数据槽，以便在 JS 回调中能访问到 env env->Initialize(); // 5. 将 env 存储到 Context 的内部字段中 // 这样在 JS 代码中，可以通过 Context 访问到对应的 Environment 对象 context->SetAlignedPointerInEmbedderData(kNodeContextEmbedderDataIndex, env); return std::unique_ptr<Environment>(env); } // ...

Environment对象是 Node.js 运行时状态的中心枢纽。所有的 JavaScript 代码都将在其关联的v8::Context中执行，所有的异步操作都将通过其关联的uv_loop_t进行调度。

事件循环的奠基：libuv 初始化

Node.js 的非阻塞 I/O 和事件驱动模型依赖于 libuv 库。在node::Start()中，libuv 的事件循环uv_loop_t被初始化。

// src/node.cc (片段) // ... uv_loop_t default_loop; int err = uv_loop_init(&default_loop); // 初始化 libuv 事件循环 if (err) { // 错误处理 return 1; } // ...

uv_loop_init()函数会初始化uv_loop_t结构体，分配必要的资源，使其准备好接收和处理事件。这个default_loop随后会被传递给CreateEnvironment()，成为node::Environment的一部分。

libuv 事件循环是 Node.js 异步编程的基础。它负责监听文件系统事件、网络事件、定时器事件等，并在事件发生时调度相应的回调函数。

JavaScript 上下文的构建：v8::Context

v8::Context是 V8 引擎中 JavaScript 代码执行的“沙箱”。每个Context都有其独立的全局对象（例如global或window）、内置对象（Object、Array、Function等）和作用域链。Node.js 在启动时会创建一个主Context。

创建Context的过程在CreateEnvironment()内部进行。

// src/node.cc (片段) // ... v8::Local<v8::Context> context = v8::Context::New(isolate); // ...

然而，v8::Context::New(isolate)的实际创建过程比看起来要复杂。V8 引擎在创建Context时，需要初始化大量的内置对象和函数。为了加速这个过程，Node.js 采用了快照（Snapshot）机制。

快照机制

快照是 V8 引擎的一项重要优化技术。它允许将一个已经初始化好的v8::Isolate或v8::Context的内存状态序列化到一个文件中。在后续的启动中，V8 可以直接从这个快照文件反序列化出预先初始化好的Isolate或Context，从而大大减少启动时间。

Node.js 在构建时就包含了预生成的 V8 快照。这个快照包含了：

• V8 的内置对象和函数。
• Node.js 一部分核心的 C++ 绑定。
• Node.js 引导 JavaScript 代码的预编译字节码。

当v8::Context::New(isolate)被调用时，如果 Node.js 配置了使用快照，V8 会直接从快照加载 Context 的初始状态，而不是从头开始构建，这显著提升了 Node.js 的启动速度。

在v8::Context::New之后，Node.js 会在Context的全局对象上设置一些初始属性，例如global、process的占位符，以及console的基本实现等。这些操作在 C++ 层面完成，是 JavaScript 引导程序 (internal/bootstrap/node.js) 运行前的准备工作。

// src/node_context_utils.cc (简化) // ... void SetupContext(v8::Local<v8::Context> context, Environment* env) { v8::Isolate* isolate = env->isolate(); v8::Local<v8::Object> global_object = context->Global(); // 设置 global 对象的原型，使其包含一些 Node.js 特有的全局变量 // v8::Local<v8::Object> global_proxy = context->Global(); // v8::Local<v8::Object> global_private = GetPrivateGlobal(context); // 注入 process 对象（初始版本） v8::Local<v8::Object> process_obj = v8::Object::New(isolate); global_object->Set(context, FIXED_ONE_BYTE_STRING(isolate, "process"), process_obj).FromJust(); // 注入 console 对象 v8::Local<v8::Object> console_obj = v8::Object::New(isolate); global_object->Set(context, FIXED_ONE_BYTE_STRING(isolate, "console"), console_obj).FromJust(); // ... 注入其他全局对象，例如 Buffer, setTimeout 等的占位符或简易实现 }

这些 C++ 级别的注入为后续 JavaScript 引导代码提供了执行的基础环境。

内置模块的加载与引导

Node.js 有大量的内置模块，其中一部分是 C++ 实现的（例如fs,net,http的底层），另一部分是 JavaScript 实现的（位于lib/internal目录）。在Environment创建之后，这些内置模块会被加载并暴露给 JavaScript。

node::loader::InitializeBuiltinModules()函数负责这个过程。

// src/node.cc (片段) // ... loader::InitializeBuiltinModules(env.get()); // ...

InitializeBuiltinModules的主要工作是：

1. 注册 C++ 绑定：将 C++ 实现的模块（例如node_buffer.cc,node_fs.cc）注册到 V8 上下文中，使其可以通过process.binding('module_name')在 JavaScript 中访问。这些绑定通常会导出一些函数或对象，供 JavaScript 层调用。
2. 加载 JavaScript 内置模块：将 Node.js 自身lib/internal目录下的 JavaScript 文件作为字符串嵌入到 C++ 代码中，然后在 V8 上下文中编译并执行。这些模块通常是纯 JavaScript 实现的，但它们构建在 C++ 绑定之上，并提供更高级别的 API。

Node.js 使用了一个叫做BuiltinLoader的机制来管理这些内置模块。它将 JavaScript 内置模块的代码字符串存储在 C++ 中，并在需要时（通常是启动时）编译并执行它们。

// src/node_builtins.cc (简化示例) // 假设有一个内部 JS 模块 'internal/per_context/setup.js' // 它的内容在构建时被转换为 C++ 字符串字面量 namespace node { namespace loader { // 这是一个简化的表示，实际是一个复杂的映射和管理机制 struct BuiltinModule { const char* id; const char* source; }; // 所有内置模块的列表 static const BuiltinModule kBuiltinModules[] = { {"internal/per_context/setup", "/* JavaScript code for setup */"}, {"internal/bootstrap/node", "/* JavaScript code for bootstrap */"}, // ... 更多内置模块 }; void InitializeBuiltinModules(Environment* env) { // 获取 V8 上下文 v8::HandleScope handle_scope(env->isolate()); v8::Local<v8::Context> context = env->context(); v8::Context::Scope context_scope(context); // 1. 注册 C++ 绑定 // 例如，注册 'buffer' 模块的 C++ 导出 // node::Buffer::Initialize(env, context->Global()); // 2. 加载 JavaScript 内置模块 // 实际会通过一个 BuiltinLoader 对象来管理 // BuiltinLoader loader(env); // for (const auto& module : kBuiltinModules) { // loader.RegisterBuiltin(module.id, module.source); // } // 假设我们现在要执行 'internal/bootstrap/node.js' // loader.CompileAndRunBuiltin(env, "internal/bootstrap/node"); } } // namespace loader } // namespace node

通过这种方式，Node.js 核心的 JavaScript 代码在用户代码执行之前就已经准备好了。

从 C++ 到 JavaScript：node::LoadEnvironment()

这是 C++ 世界与 JavaScript 世界的正式交界点。node::LoadEnvironment()函数的主要职责是执行 Node.js 的 JavaScript 引导代码，即internal/bootstrap/node.js。

// src/node.cc (片段) // ... LoadEnvironment(env.get()); // ... void LoadEnvironment(Environment* env) { v8::HandleScope handle_scope(env->isolate()); v8::Local<v8::Context> context = env->context(); v8::Context::Scope context_scope(context); // 1. 编译并执行 internal/per_context/setup.js // 这个脚本通常用于设置一些 V8 context 级别的全局变量和函数 // 例如，设置 setTimeout, setInterval 等的 C++ 绑定 loader::CompileAndRunBuiltin(env, "internal/per_context/setup"); // 2. 编译并执行 internal/bootstrap/node.js // 这是 Node.js JavaScript 引导程序的核心 loader::CompileAndRunBuiltin(env, "internal/bootstrap/node"); // 3. 标记环境已加载 env->set_has_loaded_bootstrappers(true); }

internal/per_context/setup.js是一个相对较小的脚本，主要用于设置一些特定于 V8Context的全局函数和对象，例如setTimeout,setInterval，它们的底层实现通常是 C++ 绑定。

而internal/bootstrap/node.js则是 Node.js 启动流程中最重要的 JavaScript 文件。

JavaScript 引导程序：internal/bootstrap/node.js的世界

internal/bootstrap/node.js是 Node.js 运行时创建的 JavaScript 端的核心。它在 C++ 层面被加载并执行，其主要任务是：

1. 构建process对象：这是 Node.js 全局process对象的核心，包括argv,env,version,versions,cwd(),exit(),nextTick()等。
2. 填充global对象：将Buffer,console,setTimeout,setInterval,clearTimeout,clearInterval等全局 API 注入到global对象中。
3. 初始化模块系统：设置 CommonJS 模块系统的require函数，以及 ES Modules 的加载器。
4. 准备用户代码执行环境：设置好一切，以便后续能够加载并执行用户编写的 JavaScript 代码。

让我们看一些internal/bootstrap/node.js的简化片段：

// lib/internal/bootstrap/node.js (简化) 'use strict'; // 1. 获取 C++ 绑定 (假设 C++ 已经通过 'process.binding' 暴露了) const binding = { // 获取 Node.js 的 C++ 内部绑定 // 例如 process_wrap 提供了 process.nextTick 等底层实现 // fs 提供了文件系统操作的底层实现 process_wrap: process.binding('process_wrap'), // ... 其他 C++ 绑定 }; // 2. 构建 process 对象 // C++ 层面已经创建了一个空的 process 对象，这里填充其属性和方法 const _process = global.process; // 获取 C++ 注入的空 process 对象 Object.defineProperty(_process, 'argv', { value: binding.process_wrap.argv, // 从 C++ 获取命令行参数 enumerable: true, configurable: false }); Object.defineProperty(_process, 'env', { value: binding.process_wrap.env, // 从 C++ 获取环境变量 enumerable: true, configurable: false }); // ... 更多 process 属性和方法，例如 versions, arch, platform 等 // 例如 nextTick 的实现 _process.nextTick = (callback, ...args) => { // 实际的 nextTick 会使用 C++ 绑定来实现微任务队列 binding.process_wrap.runMicrotasks(); // 触发 V8 的微任务队列 queueMicrotask(() => callback(...args)); // 将回调放入微任务队列 }; // 3. 构建 console 对象 // C++ 层面已经创建了一个空的 console 对象 const _console = global.console; _console.log = function(...args) { // 实际会通过 C++ 绑定调用 process.stdout.write binding.fs.writeSync(1, args.join(' ') + 'n'); }; // ... 其他 console 方法 // 4. 定义全局变量 (例如 Buffer) // Buffer 是 Node.js 独有的全局类 global.Buffer = require('buffer').Buffer; // 通过 require 加载 buffer 模块 // 5. 设置定时器函数 // 这些函数在 internal/per_context/setup.js 中已经有 C++ 绑定 global.setTimeout = require('timers').setTimeout; global.setInterval = require('timers').setInterval; // ... clear 对应函数 // 6. 初始化模块系统 // CommonJS 模块系统 const Module = require('internal/modules/cjs/loader'); Module.setGlobalPaths(binding.process_wrap.modulePaths); // 设置 require 的查找路径 // ES Modules 加载器 const { initializeESMLoader } = require('internal/process/esm_loader'); initializeESMLoader(); // 7. 准备执行用户代码的函数 // 这通常是一个内部函数，在用户代码执行时会被调用 function startupUserScript() { // 获取用户脚本路径 const script = _process.argv[1]; if (script) { // 运行用户脚本 (CommonJS 或 ESM) if (Module.isMainThread()) { // 如果是主线程 Module.runMain(script); // CommonJS 入口 } else { // Worker Threads 或 ESM 的入口 // ... } } } // 暴露 startupUserScript 给 C++ 调用 // 实际是通过一个内部机制，C++ 拿到这个函数句柄 global.startupUserScript = startupUserScript;

这个引导脚本是 Node.js 能够作为一个功能齐全的 JavaScript 运行时环境的关键。它连接了 C++ 提供的底层能力与 JavaScript 世界的高级抽象。

用户代码的执行：CommonJS 与 ES Modules

在internal/bootstrap/node.js执行完毕后，Node.js 已经准备好加载并运行用户编写的 JavaScript 代码了。这一步通常发生在 C++ 端的node::LoadEnvironment()之后，通过一个在Environment中注册的 JavaScript 函数句柄来触发。

CommonJS 模块

对于传统的 CommonJS 模块，Node.js 会调用Module.runMain()函数。

// lib/internal/modules/cjs/loader.js (简化) // ... // Module 构造函数 function Module(id, parent) { this.id = id; this.exports = {}; // ... } // Module._load 负责加载、编译和缓存模块 Module._load = function(request, parent, isMain) { // 1. 解析模块路径 const filename = Module._resolveFilename(request, parent, isMain); // 2. 检查缓存 let cachedModule = Module._cache[filename]; if (cachedModule) { return cachedModule.exports; } // 3. 创建新模块实例 const module = new Module(filename, parent); Module._cache[filename] = module; // 4. 加载模块内容 // 根据文件扩展名调用不同的加载器 (.js, .json, .node) module.load(filename); return module.exports; }; // 运行主模块 Module.runMain = function() { // 获取主模块路径 (通常是 process.argv[1]) const mainScript = process.argv[1]; Module._load(mainScript, null, true); // 加载主模块，isMain 为 true }; // ...

当Module.runMain()被调用时，它会使用Module._load()来加载用户指定的主模块。Module._load()会处理模块的解析、缓存、编译和执行。对于.js文件，它会读取文件内容，然后将其包裹在一个函数中执行，并将exports、require、module、__filename、__dirname作为参数传递进去。

// 假设用户文件 app.js // console.log("Hello from user app!"); // const os = require('os'); // console.log(os.platform()); // Node.js 实际执行时会变成类似这样： (function(exports, require, module, __filename, __dirname) { console.log("Hello from user app!"); const os = require('os'); console.log(os.platform()); })(exports, require, module, filename, dirname);

ES Modules

对于 ES Modules，加载流程则更为复杂，它遵循 ECMAScript 规范。Node.js 内部有一个 ES Module Loader，负责解析import和export语句，进行模块图构建、实例化和求值。

internal/process/esm_loader.js在引导阶段被初始化，它会设置node:module导出的Loader类，并处理import语句的解析和加载。

当 Node.js 启动时，如果入口文件被识别为 ES Module（例如，文件扩展名为.mjs或package.json中type字段为"module"），则会通过 ES Module Loader 来加载。

// lib/internal/process/esm_loader.js (简化) // ... const { ESMLoader } = require('internal/modules/esm/loader'); const { get // 从 C++ 绑定获取 initializeESMLoader() { // 创建并初始化 ESMLoader 实例 const loader = new ESMLoader(); // ... 注册各种 hook，例如 resolve, load // 使得 Node.js 能够处理 import 语句 // global.getBuiltinESMLoader = () => loader; // 暴露给内部使用 } // ...

ESM 的加载过程涉及到：

1. 解析（Parse）：将模块代码解析成抽象语法树（AST）。
2. 加载（Load）：获取模块的源代码，以及其所有import声明引用的模块。
3. 链接（Link）：将模块的import和export绑定到对应的模块。
4. 求值（Evaluate）：执行模块代码，填充其导出的值。

这是一个异步且可能涉及网络请求的过程（例如，未来支持 HTTP 导入），但对于本地文件，Node.js 会高效地处理。

事件循环的运转与生命周期

在用户代码执行完毕后，如果应用程序还有待处理的异步任务（例如，一个setTimeout，一个网络请求，或者一个文件读取操作），Node.js 进程并不会立即退出。相反，它会进入由libuv提供的事件循环。

// src/node.cc (片段) // ... int exit_code = uv_run(&default_loop, UV_RUN_DEFAULT); // ...

uv_run()是 libuv 事件循环的核心函数。它会不断地检查事件队列，并在有事件发生时执行相应的回调函数。

事件循环的典型阶段包括：

1. Timers (定时器)：执行setTimeout()和setInterval()的回调。
2. Pending Callbacks (待处理回调)：执行上一个循环迭代中，系统操作（如 TCP 错误）的回调。
3. Idle, Prepare (空闲/准备)：仅在内部使用。
4. Poll (轮询)：等待新的 I/O 事件，例如网络请求到达、文件读取完成。这是事件循环中最长的时间段。如果队列中有定时器或 I/O 回调，它会等待直到这些事件准备就绪。
5. Check (检查)：执行setImmediate()的回调。
6. Close Callbacks (关闭回调)：执行close事件的回调，例如socket.on('close')。

uv_run()的模式：

• UV_RUN_DEFAULT：只要有活跃的句柄（handles）或请求（requests），事件循环就会持续运行。这是 Node.js 的默认模式。
• UV_RUN_ONCE：事件循环会阻塞直到有事件发生，然后处理一个或多个事件，最后返回。
• UV_RUN_NOWAIT：事件循环会处理所有可用的事件，但不会阻塞。

Node.js 应用程序的生命周期由uv_run(&default_loop, UV_RUN_DEFAULT)维持。只有当所有活跃的句柄（如打开的服务器、活动的定时器、待处理的 I/O 操作）都关闭，事件循环才会退出，进程随之终止。

性能优化：快照（Snapshot）与启动速度

在前面我们提到了快照机制在v8::Context创建中的应用。实际上，Node.js 对快照的使用更为广泛，它是 Node.js 快速启动的关键之一。

Node.js 在编译时会生成一个包含 V8 引擎和 Node.js 核心代码的快照。这个快照不仅仅包含 V8 的内置对象，还包含了 Node.js 核心 JavaScript 模块（例如internal/bootstrap/node.js及其依赖）的预编译字节码和数据。

快照带来的好处：

1. 减少启动时间：无需在运行时重新解析和编译大量的 JavaScript 代码，直接从快照加载已经预编译好的字节码。
2. 减少内存消耗：多个Isolate可以共享同一个快照的只读部分，节省内存。
3. 一致性：确保每个 Node.js 实例都以相同的、预定义的状态启动。

当 Node.js 启动时，它会告诉 V8 使用这个内置的快照。V8 会根据快照快速地初始化Isolate和Context，直接进入执行阶段，省去了繁重的初始化工作。

结束语

通过上述深入的剖析，我们已经完整地走过了 Node.js 的启动流程。从 C++main函数开始，我们见证了 V8 引擎的初始化、libuv 事件循环的建立、node::Environment这一核心对象的诞生，以及v8::Context的精细构建。随后，我们了解了 Node.js 如何通过 C++ 绑定和 JavaScript 引导程序 (internal/bootstrap/node.js) 来构建process、global等全局对象，并初始化其模块系统。最终，用户编写的 JavaScript 代码被加载并执行，应用程序进入由 libuv 驱动的事件循环，等待并处理异步事件。这个复杂而高效的启动过程，是 Node.js 能够成为高性能、事件驱动的 JavaScript 运行时的基石。理解这些底层机制，无疑能帮助我们更好地驾驭 Node.js，编写出更健壮、更高效的应用。