Nodejs封装了所有与底层交流的信息，给开发者提供一致的接口定义。在不断升级v8和libuv的同时，依然能够做到接口的一致性，这个就是nodejs想要实现的目标。

$ ./configure
$ make -j4

{
  // 定义的‘node_core_target_name%‘就是‘node‘,
  ‘target_name‘: ‘<(node_core_target_name)‘,
  ‘type‘: ‘executable‘, // 这里的类型是可执行文件

  ‘defines‘: [
    ‘NODE_WANT_INTERNALS=1‘,
  ],

  ‘includes‘: [
    ‘node.gypi‘
  ],

  ‘include_dirs‘: [
    ‘src‘,
    ‘deps/v8/include‘
  ],

  ‘sources‘: [
    ‘src/node_main.cc‘
  ],
  ... ...
}

{
  // 这里定义的‘node_lib_target_name‘就是libnode
  ‘target_name‘: ‘<(node_lib_target_name)‘,
  ‘type‘: ‘<(node_intermediate_lib_type)‘,
  ‘includes‘: [
    ‘node.gypi‘,
  ],

  ‘include_dirs‘: [
    ‘src‘,
    ‘<(SHARED_INTERMEDIATE_DIR)‘ # for node_natives.h
  ],
  ... ...
  ‘actions‘: [
    {
      ‘action_name‘: ‘node_js2c‘,
      ‘process_outputs_as_sources‘: 1,
      ‘inputs‘: [
        # Put the code first so it‘s a dependency and can be used for invocation.
        ‘tools/js2c.py‘,
        ‘<@(library_files)‘,
        ‘config.gypi‘,
        ‘tools/js2c_macros/check_macros.py‘
      ],
      ‘outputs‘: [
        ‘<(SHARED_INTERMEDIATE_DIR)/node_javascript.cc‘,
      ],
      ‘conditions‘: [
        [ ‘node_use_dtrace=="false" and node_use_etw=="false"‘, {
          ‘inputs‘: [ ‘tools/js2c_macros/notrace_macros.py‘ ]
        }],
        [ ‘node_debug_lib=="false"‘, {
          ‘inputs‘: [ ‘tools/js2c_macros/nodcheck_macros.py‘ ]
        }],
        [ ‘node_debug_lib=="true"‘, {
          ‘inputs‘: [ ‘tools/js2c_macros/dcheck_macros.py‘ ]
        }]
      ],
      ‘action‘: [
        ‘python‘, ‘<@(_inputs)‘,
        ‘--target‘, ‘<@(_outputs)‘,
      ],
    },
  ],

namespace node {

namespace native_module {
  ...

  static const uint8_t fs_raw[] = {...}

  ...

  void NativeModuleLoader::LoadJavaScriptSource() {
    ...
    source_.emplace("fs", UnionBytes{fs_raw, 50659});
    ...
  }
  UnionBytes NativeModuleLoader::GetConfig() {
    return UnionBytes(config_raw, 3017);  // config.gypi
  }
}

MaybeLocal<Value> Environment::BootstrapInternalLoaders() {
  EscapableHandleScope scope(isolate_);

  // Create binding loaders
  std::vector<Local<String>> loaders_params = {
      process_string(),
      FIXED_ONE_BYTE_STRING(isolate_, "getLinkedBinding"),
      FIXED_ONE_BYTE_STRING(isolate_, "getInternalBinding"),
      primordials_string()};
  // 这里的GetInternalBinding便是我们调用`getInternalBinding`执行的函数。如果你不知道为什么js可以调用C++函数的话，请参考这篇文章：《如何正确地使用v8嵌入到我们的C++应用中》
  std::vector<Local<Value>> loaders_args = {
      process_object(),
      NewFunctionTemplate(binding::GetLinkedBinding)
          ->GetFunction(context())
          .ToLocalChecked(),
      NewFunctionTemplate(binding::GetInternalBinding)
          ->GetFunction(context())
          .ToLocalChecked(),
      primordials()};
      ...
}

const loaderExports = {
  internalBinding,
  NativeModule,
  require: nativeModuleRequire
};

let internalBinding;
{
  const bindingObj = Object.create(null);
  // eslint-disable-next-line no-global-assign
  internalBinding = function internalBinding(module) {
    let mod = bindingObj[module];
    if (typeof mod !== ‘object‘) {
      // 这里调用我们的C++方法
      mod = bindingObj[module] = getInternalBinding(module);
      moduleLoadList.push(`Internal Binding ${module}`);
    }
    return mod;
  };
}

MaybeLocal<Value> Environment::BootstrapInternalLoaders() {
  ... ...
  // 这里的loader_exports便是执行完loader.js之后返回的值
  Local<Value> loader_exports;
  if (!ExecuteBootstrapper(
           this, "internal/bootstrap/loaders", &loaders_params, &loaders_args)
           .ToLocal(&loader_exports)) {
    return MaybeLocal<Value>();
  }
  CHECK(loader_exports->IsObject());
  Local<Object> loader_exports_obj = loader_exports.As<Object>();

  // 此时internal_binding_loader的值便是loader_exports.internalBinding，下面的同理
  Local<Value> internal_binding_loader =
      loader_exports_obj->Get(context(), internal_binding_string())
          .ToLocalChecked();
  CHECK(internal_binding_loader->IsFunction());
  set_internal_binding_loader(internal_binding_loader.As<Function>());

  // 注意这里的require是native_module的require，有别于第三方包的reuqire
  Local<Value> require =
      loader_exports_obj->Get(context(), require_string()).ToLocalChecked();
  CHECK(require->IsFunction());
  set_native_module_require(require.As<Function>());
  ...
}

MaybeLocal<Value> Environment::BootstrapNode() {
  ... ...
  std::vector<Local<Value>> node_args = {
      process_object(),
      native_module_require(),
      internal_binding_loader(), // 这个就是刚才的那个internalBinding
      Boolean::New(isolate_, is_main_thread()),
      Boolean::New(isolate_, owns_process_state()),
      primordials()};
  ... ...
}

void GetInternalBinding(const FunctionCallbackInfo<Value>& args) {
  ... ...
  // 查找模块，在哪里查找？
  node_module* mod = FindModule(modlist_internal, *module_v, NM_F_INTERNAL);
  if (mod != nullptr) {
    exports = InitModule(env, mod, module);
    // 什么是constants模块？
  } else if (!strcmp(*module_v, "constants")) {
    exports = Object::New(env->isolate());
    CHECK(
        exports->SetPrototype(env->context(), Null(env->isolate())).FromJust());
    DefineConstants(env->isolate(), exports);
  } else if (!strcmp(*module_v, "natives")) {
    exports = native_module::NativeModuleEnv::GetSourceObject(env->context());
    // Legacy feature: process.binding(‘natives‘).config contains stringified
    // config.gypi
    CHECK(exports
              ->Set(env->context(),
                    env->config_string(),
                    native_module::NativeModuleEnv::GetConfigString(
                        env->isolate()))
              .FromJust());
  } else {
    return ThrowIfNoSuchModule(env, *module_v);
  }

  // 这里导出了exports这个变量~
  args.GetReturnValue().Set(exports);
}

#define NODE_MODULE_CONTEXT_AWARE_INTERNAL(modname, regfunc)                     NODE_MODULE_CONTEXT_AWARE_CPP(modname, regfunc, nullptr, NM_F_INTERNAL

if (mp->nm_flags & NM_F_INTERNAL) {
    mp->nm_link = modlist_internal;
    modlist_internal = mp;
} else if (!node_is_initialized) {
  // "Linked" modules are included as part of the node project.
  // Like builtins they are registered *before* node::Init runs.
  mp->nm_flags = NM_F_LINKED;
  mp->nm_link = modlist_linked;
  modlist_linked = mp;
} else {
  thread_local_modpending = mp;
}

const fs = require(‘fs‘)

module.exports = () => {
  fs.open(‘test.js‘, () => {
    // balabala
  })
}

~ $ node
> require(‘module‘).wrapper
[ ‘(function (exports, require, module, __filename, __dirname) { ‘,
  ‘\n});‘ ]
>

binding.open(pathModule.toNamespacedPath(path),
               flagsNumber,
               mode,
               req);

env->SetMethod(target, "close", Close);
env->SetMethod(target, "open", Open);

const req = new FSReqCallback();
req.oncomplete = callback;

Local<FunctionTemplate> fst = env->NewFunctionTemplate(NewFSReqCallback);
fst->InstanceTemplate()->SetInternalFieldCount(1);
fst->Inherit(AsyncWrap::GetConstructorTemplate(env));
Local<String> wrapString =
    FIXED_ONE_BYTE_STRING(isolate, "FSReqCallback");
fst->SetClassName(wrapString);
target
    ->Set(context, wrapString,
          fst->GetFunction(env->context()).ToLocalChecked())
    .Check();

AsyncCall(env, req_wrap_async, args, "open", UTF8, AfterInteger,
              uv_fs_open, *path, flags, mode);