前言

之前用过一段时间的v8 ，也只是会初始化那个流程，最近想深入了解一下，所以想要通过学习 nodejs 来加深理解。这篇文章主要是讲讲 nodejs 的初始化流程，如有错误，烦请指教~。（本文分析基于 v10.9.0，本文会尽量避免大段源码，但是为了有理有据，还是会放上一些精简过并带有注释的代码上来）。

Helloworld 镇楼：

const http = require('http');
const hostname = '127.0.0.1';
const port = 8888;

http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello World\n');
}).listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});

写过 nodejs 的都能看懂如上代码。寥寥数行，就创建了一个 http 服务。第一行代码，就出现了一个 require 关键字，那么 require 是从何而来呢？带着这个问题，我们一起去看下吧。

启动流程

1. node 的目录结构，此处就不再分析了。最重要的就是 src 和 lib 了。 src 路径下是 node 的 C++ 实现的主要源码目录，而 lib 主要是 JavaScript 实现所在目录。稍微有一些 C++ 编程基础的同学应该知道，C++ 的启动函数就是 main 函数。那么 node 的启动函数在哪呢。通过全文搜索，可以确定，启动函数就在 src/node_main.cc 这个文件当中了。此处截取部分源码：

// windows 启动方法。
int wmain(int argc, wchar_t* wargv[]) {
  //...
  // 启动方法。
  return node::Start(argc, argv);
}
//...
// 类linux 启动方法。
int main(int argc, char* argv[]) {
    // ...
    // 启动方法。
    return node::Start(argc, argv);
}

可以看到，这个只是一个外壳，做了一些逻辑判断，最终的核心就是调用 Start 方法。

2. Start 方法位于 src/node.cc:

int Start(int argc, char** argv) {
    //...
    Init(&argc, const_cast<const char**>(argv), &exec_argc, &exec_argv); // 1.
    // v8 初始化。
    InitializeV8Platform(per_process_opts->v8_thread_pool_size);
    v8_initialized = true;
    // 开始事件循环。
    const int exit_code =
        Start(uv_default_loop(), args, exec_args);  // 2.
    //... v8 开始销毁。
    v8_initialized = false;
    V8::Dispose();
    //...
    return exit_code;
}

可以看到，Start 方法主要是执行了一个 Init 方法以及对 v8 进行了初始化的操作，然后开启了整个事件循环流程。

2.1 来看看 Init 方法做了些什么事情，同样位于 src/node.cc 中：

void Init(int* argc,
          const char** argv,
          int* exec_argc,
          const char*** exec_argv) {
  //... 注册内部模块。 此处暂时不细讲。
  RegisterBuiltinModules();
  //...  处理参数，打印 help 等。
  ProcessArgv(argv, exec_argv, false);
  //...
}

2.2 接着让我们看看里面这个 Start 方法做了什么。同样位于 src/node.cc 中：

inline int Start(uv_loop_t* event_loop,
                 const std::vector<std::string>& args,
                 const std::vector<std::string>& exec_args) {
  //... 开始创建 Isolate 实例。 
  Isolate* const isolate = NewIsolate(allocator.get(), event_loop);
  //...
  {
    //... 又是一个 Start 。
    exit_code = Start(isolate, isolate_data.get(), args, exec_args);
  }
  // isolate 销毁。
  isolate->Dispose();
  //...
  return exit_code;
}

参数检查什么的就略过了，上来先创建了一个 Isolate 实例，这个实例相当于是一个 js 独立环境，更粗略一点，比作一个页面。 中间又调用了一个 Start 方法，最终处理一下 isolate 的销毁。

3. 那接着来看这个 Start 方法（麻木了，都叫 Start 方法。）同样位于 src/node.cc 中：

inline int Start(Isolate* isolate, IsolateData* isolate_data,
                 const std::vector<std::string>& args,
                 const std::vector<std::string>& exec_args) {
  //... 创建一个 Context
  Local<Context> context = NewContext(isolate); // 1.
  //... 创建一个 Environment 实例，并开启 Start 方法。
  Environment env(isolate_data, context, v8_platform.GetTracingAgentWriter());
  env.Start(args, exec_args, v8_is_profiling); // 2.
  {
    //... 环境加载
    LoadEnvironment(&env);  // 3.
    //...
  }

  {
    //...
    do {
      // 事件循环启动。libuv 相关。 4.
      uv_run(env.event_loop(), UV_RUN_DEFAULT);
      //...
    } while (more == true);
    //...
  }
  //...
  const int exit_code = EmitExit(&env);
  //... 善后工作，资源回收等等。
  return exit_code;
}

Context 又是 v8 的一个概念，相当于执行上下文，js 的执行上下文，可以实现互不影响。比如一个页面上嵌套了某个页面，那么他们之间的 js 上下文环境就不一样。此处需要关注 1 , 2，3，4 四个方法。

3.1 先来看看 1 ,如何创建的 Context。NewContext 同样位于 src/node.cc 中：

Local<Context> NewContext(Isolate* isolate,
                          Local<ObjectTemplate> object_template) {
  // 使用 v8 的 api 创建 Context。 
  auto context = Context::New(isolate, nullptr, object_template);
  // ...
  {
    // ... Run lib/internal/per_context.js
    // 获取 per_context.js 文件的字符串。
    Local<String> per_context = NodePerContextSource(isolate);
    // 编译运行，v8的模板代码。
    ScriptCompiler::Source per_context_src(per_context, nullptr);
    Local<Script> s = ScriptCompiler::Compile(
        context,
        &per_context_src).ToLocalChecked();
    s->Run(context).ToLocalChecked();
  }
  return context;
}

此方法不仅仅创建了一个 Context，而且还预加载执行了一段js。注意这个 NodePerContextSource 方法只有编译过才会有这个文件。

3.1.1 看一下这个方法.文件位于node_javascript.cc 中：

v8::Local<v8::String> NodePerContextSource(v8::Isolate* isolate) {
    return internal_per_context_value.ToStringChecked(isolate);
}
static const uint8_t raw_internal_per_context_value[] = { 39,...}
static struct : public v8::String::ExternalOneByteStringResource {
    const char* data() const override {
        return reinterpret_cast<const char*>(raw_internal_per_context_value);
    }
    //...
    v8::Local<v8::String> ToStringChecked(v8::Isolate* isolate) {
        return v8::String::NewExternalOneByte(isolate, this).ToLocalChecked();
    }
} internal_per_context_value;

看到这里应该知道了，就是把 raw_internal_per_context_value 这个数组转成 v8 的字符串返回出去。那么问题来了，这个数组里面到底是什么东西呢。

3.1.2 猜也没法猜，那就打印一下呗。打印数组相关代码如下：

#include <string>
#include <iostream>
static const unsigned char raw_internal_per_context_value[] = {39,...}
int main() {
    std::cout << (char *)raw_internal_bootstrap_loaders_value << std::endl;
}

g++ -o test test.cc & ./test 就可以看到内容了。你会惊奇的发现，这不就是 lib/internal/per_context.js 文件的内容吗？是的，的确是这样，他就是把这段文本直接在编译期间就编成C++字符数组，为了在启动的时候加快启动速度，不至于现场去读文件从而引发文件加载速度的等等一系列问题。至于此 js 文件内容，在此先不做讲解。接着让我回到 4~5步的方法2当中。

**3.2 ** env.Start 方法位于 src/env.cc 中：

void Environment::Start(const std::vector<std::string>& args,
                        const std::vector<std::string>& exec_args,
                        bool start_profiler_idle_notifier) {
    //... 一大堆的 uv 操作等等。
    // 设置了 process。
    auto process_template = FunctionTemplate::New(isolate()); 
    process_template->SetClassName(FIXED_ONE_BYTE_STRING(isolate(), "process"));
    // ...
}

可以看到其中设置了 process 是什么，此处设置了之后，在js里面就可以直接拿到 process 变量了。

3.3 LoadEnvironment 方法在 src/node.cc 中：

void LoadEnvironment(Environment* env) {
  //...
  // 加载 lib/internal/bootstrap/loaders.js 和 node.js 进来。
  // FIXED_ONE_BYTE_STRING 就是一个转换字符串的宏。
  Local<String> loaders_name =
      FIXED_ONE_BYTE_STRING(env->isolate(), "internal/bootstrap/loaders.js");
  // LoadersBootstrapperSource 是获取 loaders.js 的文件内容。 GetBootstrapper 方法是用来
  // 执行 js 的。
  MaybeLocal<Function> loaders_bootstrapper =
      GetBootstrapper(env, LoadersBootstrapperSource(env), loaders_name);
  //...
  // 获取 global 对象
  Local<Object> global = env->context()->Global();
  //...
  // 暴露 global 出去，在 js 中可以访问。
  global->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "global"), global);

  // 创建bind,linked_binding,internal_binding
  Local<Function> get_binding_fn =
      env->NewFunctionTemplate(GetBinding)->GetFunction(env->context())
          .ToLocalChecked();
  //...

  // 执行 internal/loaders.js,node.js 里面的方法。
  if (!ExecuteBootstrapper(env, loaders_bootstrapper.ToLocalChecked(),
                           arraysize(loaders_bootstrapper_args),
                           loaders_bootstrapper_args,
                           &bootstrapped_loaders)) {
    return;
  }
  //...
}

static void GetBinding(const FunctionCallbackInfo<Value>& args) {
  // ... 通过参数获取模块名。
  Local<String> module = args[0].As<String>();
  //... 获取内部模块。此处就是通过2.1步骤中的 RegisterBuiltinModules 宏处理之后的东西来获取的。
  node_module* mod = get_builtin_module(*module_v);
  Local<Object> exports;
  if (mod != nullptr) {
    // 调用模块初始化方法。
    exports = InitModule(env, mod, module);
  }
  // ... 设置返回值。
  args.GetReturnValue().Set(exports);
}

代码很长，但是条理还是挺清晰的。这里进行了一些绑定操作和一些初始化方法的调用逻辑。此处也可以知道，GetBinding 类似的东西是什么。调用的 js 如何执行需要和 js 一起看才能明白。此处先不讲解了。

3.4 uv_run 这个方法此处也不细讲了。 libuv 这个库还没有详细了解。等待了解之后，补上 libuv 的相关调用分析，此处我们知道，在这里开始执行事件循环了。

结语

讲了这么多，大家应该对 nodejs 的启动流程有了一个大致的了解了吧。虽然开头说少点源码，可是后来还是夹杂了很多的源码，哈哈，有一种上当的感觉。后面再讲讲模块加载，libuv加载的相关东西。这次分析就到此结束吧，大家休息~