Node.js 概述

const server = http.createServer();
server.on('request', (req, res) => { /* 处理请求 */ });
server.on('connection', (socket) => { /* 新连接 */ });
server.on('close', () => { /* 服务器关闭 */ });

// 文件复制 — 流式处理（内存友好）
fs.createReadStream('source.bin')
  .pipe(fs.createWriteStream('dest.bin'));

// global 对象的关键成员（简化）
global = {
  process: {
    argv: [],           // 命令行参数
    env: {},            // 环境变量
    version: 'v22.x',   // Node 版本
    versions: {},       // 各组件版本（v8, uv, zlib...）
    moduleLoadList: [], // 模块加载顺序记录
    binding: Function,  // 访问 C++ Binding 的内部接口
  },
  Buffer: [Function: Buffer],
  setTimeout, setInterval, setImmediate,
  console,
  require, module, exports,  // 模块系统（在模块作用域内）
  __dirname, __filename,     // 路径信息（在模块作用域内）
}

// Node 内部对每个模块的包裹方式
(function(exports, require, module, __filename, __dirname) {
  // 用户的代码写在这里
  // exports — 模块导出对象的引用
  // require — 模块加载函数
  // module — 当前模块对象（含 id, filename, children, paths 等）
  // __filename — 当前文件绝对路径
  // __dirname — 当前文件所在目录绝对路径
});

# 版本管理（推荐 nvm 或 fnm）
nvm install 22
nvm use 22

# 验证安装
node --version
npm --version

# 运行脚本
node app.js
node --experimental-modules app.mjs  # ESM

# 调试
node --inspect app.js
node --inspect-brk app.js  # 首行断点

node-10.x/
├── deps               # Node 依赖的底层库
│   ├── acorn          # JavaScript 解析库
│   ├── cares          # 异步 DNS 解析库 (c-ares)
│   ├── gtest          # C/C++ 单元测试框架
│   ├── http_parser    # C 语言 HTTP 解析库 (llhttp 前身)
│   ├── icu-small      # 跨平台 Unicode 编码集
│   ├── nghttp2        # HTTP/2 协议库
│   ├── node-inspect   # Node 调试工具
│   ├── npm            # Node 包管理工具
│   ├── openssl        # 通信/加密算法库
│   ├── uv (libuv)     # 异步 I/O 库
│   ├── v8             # JavaScript 引擎
│   └── zlib           # 数据压缩/解压库
├── lib                # 原生 JavaScript 模块
│   ├── fs.js
│   ├── http.js
│   ├── buffer.js
│   ├── events.js
│   └── internal/      # 内部模块
│       ├── bootstrap/ # 启动引导模块
│       │   ├── cache.js
│       │   ├── loaders.js
│       │   └── node.js
│       ├── modules/   # 模块系统实现
│       │   ├── cjs/
│       │   └── esm/
│       └── process/
├── src                # Node 核心 C++ 源码
│   ├── node_main.cc   # Node 启动入口
│   └── node.cc        # Node 启动主逻辑
└── tools              # 编译所需工具

// node_main.cc (简化)
int main(int argc, char* argv[]) {
  #ifdef _WIN32
    // Windows 平台特殊处理
    return node::Start(argc, argv);
  #else
    // Unix/macOS 平台
    return node::Start(argc, argv);
  #endif
}

int Start(int argc, char** argv) {
  // 1. 注册内置模块、处理命令行参数
  Init(&args, &exec_args);

  // 2. 初始化 V8 引擎
  V8::Initialize();

  // 3. 调用第二个 Start，传入默认事件循环
  Start(uv_default_loop(), args, exec_args);
}

inline int Start(uv_loop_t* event_loop,
                 std::vector<std::string>& args,
                 std::vector<std::string>& exec_args) {
  // 1. 创建独立的 V8 引擎实例
  Isolate* isolate = NewIsolate(allocator.get());

  // 2. 配置 V8 实例作用域
  Locker locker(isolate);
  Isolate::Scope isolate_scope(isolate);
  HandleScope handle_scope(isolate);

  // 3. 调用第三个 Start
  Start(isolate, isolate_data.get(), args, exec_args);
}

inline int Start(Isolate* isolate,
                 IsolateData* isolate_data,
                 std::vector<std::string>& args,
                 std::vector<std::string>& exec_args) {
  // 1. 创建 V8 Context
  Context::Scope context_scope(context);

  // 2. 创建 Node 运行环境
  Environment env(isolate_data, context, ...);
  env.Start(args, exec_args, v8_is_profiling);

  // 3. 加载模块和用户代码
  LoadEnvironment(&env);

  // 4. 启动 libuv 事件循环
  uv_run(env.event_loop(), UV_RUN_DEFAULT);

  // 5. 事件循环结束，清理退出
  EmitExit(&env);
  env.RunCleanup();
  RunAtExit(&env);
}

void LoadEnvironment(Environment* env) {
  // 1. 获取 loaders.js 和 node.js 的源码
  Local<String> loaders_name = ...("internal/bootstrap/loaders.js");
  Local<Function> loaders_bootstrapper = ...(LoadersBootstrapperSource(env), loaders_name);

  Local<String> node_name = ...("internal/bootstrap/node.js");
  Local<Function> node_bootstrapper = ...(NodeBootstrapperSource(env), node_name);

  // 2. 将 global 挂载到 Context
  Local<Object> global = env->context()->Global();
  global->Set(env->isolate(), "global", global);

  // 3. 执行启动引导函数
  ExecuteBootstrapper(env, loaders_bootstrapper, ...);
  ExecuteBootstrapper(env, node_bootstrapper, ...);
}

static bool ExecuteBootstrapper(
    Environment* env,
    Local<Function> bootstrapper,
    int argc, Local<Value> argv[],
    Local<Value>* out) {
  return bootstrapper->Call(
      env->context(), Null(env->isolate()), argc, argv).ToLocal(out);
}

$ countapi ./
Node API Used Times
┌────────────────┬───────┐
│ module         │ count │
├────────────────┼───────┤
│ path           │ 134   │
│ fs             │ 121   │
│ util           │ 16    │
│ os             │ 8     │
│ vm             │ 8     │
│ child_process  │ 7     │
│ crypto         │ 5     │
│ assert         │ 5     │
│ events         │ 5     │
│ stream         │ 3     │
│ url            │ 2     │
│ zlib           │ 2     │
│ http           │ 2     │
│ https          │ 2     │
└────────────────┴───────┘

// webpack/lib/webpack.js - 入口文件的模块依赖
const Compiler = require('./Compiler')
const MultiCompiler = require('./MultiCompiler')
const NodeEnvironmentPlugin = require('./node/NodeEnvironmentPlugin')
const WebpackOptionsApply = require('./WebpackOptionsApply')
const WebpackOptionsDefaulter = require('./WebpackOptionsDefaulter')
const validateSchema = require('./validateSchema')
const WebpackOptionsValidationError = require('./WebpackOptionsValidationError')
const webpackOptionsSchema = require('../schemas/WebpackOptions.json')
const RemovedPluginError = require('./RemovedPluginError')

"dependencies": {
  "@webassemblyjs/ast": "1.7.8",
  "@webassemblyjs/helper-module-context": "1.7.8",
  "acorn": "^5.6.2",
  "ajv": "^6.1.0",
  "chrome-trace-event": "^1.0.0",
  "memory-fs": "~0.4.1",
  "mkdirp": "~0.5.0",
  "neo-async": "^2.5.0",
  "uglifyjs-webpack-plugin": "^1.2.4",
  "watchpack": "^1.5.0",
  "webpack-sources": "^1.3.0"
}

// webpack/lib/Compiler.js
if (targetFile.match(/\/|\\/)) {
  const dir = path.dirname(targetFile)
}

// webpack/lib/ContextModuleFactory.js
const subResource = path.join(directory, segment)

// webpack/lib/ContextReplacementPlugin.js
result.resource = path.resolve(result.resource, newContentResource)

// webpack/lib/Chunk.js
Object.defineProperty(Chunk.prototype, "forEachModule", {
  configurable: false,
  value: util.deprecate(function() { /* ... */ }, 'deprecated')
})

// copy-concurrently/copy.js - 文件拷贝的流式实现
fs.createReadStream(from)
  .once('error', onError)
  .pipe(writeStreamAtomic(to, writeOpts))
  .once('error', onError)
  .once('close', function () {
    if (errored) return
    if (opts.mode != null) {
      resolve(chmod(to, opts.mode))
    } else {
      resolve()
    }
  })

// node/lib/internal/streams/legacy.js
const EE = require('events')
const util = require('util')

function Stream () {
  EE.call(this)
}
util.inherits(Stream, EE)

Stream.prototype.pipe = function(dest, options) {
  source.on('data', ondata)
  source.on('end', onend)
  source.on('close', onclose)
  source.on('error', onerror)
  dest.on('drain', ondrain)
  dest.emit('pipe', source)
  return dest
}

// webpack/lib/Compilation.js
waitForBuildingFinished(module, callback) {
  let callbackList = this._buildingModules.get(module)
  if (callbackList) {
    callbackList.push(() => callback())
  } else {
    process.nextTick(callback)  // 使用 nextTick 调度任务
  }
}

const EventEmitter = require('events')
class EE extends EventEmitter {}
const yy = new EE()

yy.on('event', () => console.log('事件触发'))
setTimeout(() => console.log('0ms 定时器'), 0)
setTimeout(() => console.log('100ms 定时器'), 100)
setImmediate(() => console.log('immediate 回调'))
process.nextTick(() => console.log('nextTick 回调'))

Promise.resolve().then(() => {
  yy.emit('event')
  process.nextTick(() => console.log('Promise 内 nextTick'))
  console.log('Promise 第一次回调')
})
.then(() => console.log('Promise 第二次回调'))

// 输出顺序：
// nextTick 回调
// Promise 第一次回调
// 事件触发
// Promise 内 nextTick
// Promise 第二次回调
// 0ms 定时器
// immediate 回调
// 100ms 定时器