Node.js运行时启动流程 ​

// 列出所有内置模块
console.log(require('module').builtinModules);
// ['assert', 'buffer', 'child_process', 'fs', ...]

// lib/internal/per_context/primordials.js
// 在任何用户代码运行前保存原始方法
primordials = {
  ArrayPrototypeMap: Array.prototype.map,
  ObjectFreeze: Object.freeze,
  PromiseResolve: Promise.resolve,
  // ...
};

// 这样即使用户修改Array.prototype.map
// Node.js内部代码仍可使用原始方法

// lib/internal/bootstrap/node.js
function setupProcessObject() {
  // 基本属性
  process.version = 'v20.10.0';
  process.versions = { node: '20.10.0', v8: '11.8.172.17', ... };
  process.arch = 'x64';
  process.platform = 'win32';
  
  // PID和目录
  process.pid;      // 来自C++
  process.cwd();    // 来自C++
  
  // 环境变量
  process.env;      // 来自C++
  
  // 标准流
  process.stdin;    // 延迟初始化
  process.stdout;
  process.stderr;
}

// lib/internal/bootstrap/loader.js
function initializeModuleLoader() {
  // CommonJS加载器
  const CJSModule = require('internal/modules/cjs/loader');
  
  // ES模块加载器
  const ESMLoader = require('internal/modules/esm/loader');
  
  // 设置require函数
  globalThis.require = CJSModule.createRequire(process.cwd());
}

// lib/internal/main/run_main_module.js
async function runMainEntry(main) {
  // 解析文件路径
  const resolvedMain = path.resolve(main);
  
  // 判断是ESM还是CJS
  if (shouldUseESM(resolvedMain)) {
    // ES模块
    await import(resolvedMain);
  } else {
    // CommonJS
    require(resolvedMain);
  }
}

function shouldUseESM(filename) {
  // 1. 检查文件扩展名
  if (filename.endsWith('.mjs')) return true;
  if (filename.endsWith('.cjs')) return false;
  
  // 2. 检查package.json的type字段
  const pkg = findPackageJson(filename);
  if (pkg?.type === 'module') return true;
  
  // 3. 默认CommonJS
  return false;
}

// CommonJS编译
function compileModule(filename, content) {
  // 包装成函数
  const wrapped = 
    '(function (exports, require, module, __filename, __dirname) { ' +
    content +
    '\n});';
  
  // V8编译并执行
  const fn = vm.runInThisContext(wrapped, { filename });
  fn.call(exports, exports, require, module, filename, dirname);
}

// 当以下条件都满足时，事件循环结束：
// 1. 没有活跃的定时器
// 2. 没有活跃的I/O操作
// 3. 没有活跃的子进程
// 4. 没有活跃的服务器监听
// 5. 微任务队列为空

// 保持进程运行的方法：
setInterval(() => {}, 1000);  // 定时器
http.createServer().listen(3000);  // 服务器
process.stdin.resume();  // 等待输入

// 生成快照
const { snapshot } = require('node:sea');
snapshot.createSync({ main: 'app.js' });

// 快照可以大幅减少启动时间
// 因为跳过了解析和编译阶段

// 内置性能API
const { performance, PerformanceObserver } = require('perf_hooks');

// 测量模块加载时间
const observer = new PerformanceObserver((list) => {
  for (const entry of list.getEntries()) {
    console.log(`${entry.name}: ${entry.duration}ms`);
  }
});
observer.observe({ entryTypes: ['node'] });

// 内置启动时间标记
console.log(process.uptime());  // 进程运行时间（秒）

// 更详细的启动标记
// node --trace-startup app.js

// 启动事件顺序
process.on('beforeExit', () => {
  // 事件循环即将退出（还可以添加新任务）
});

process.on('exit', (code) => {
  // 进程即将退出（只能同步操作）
});

// 模块初始化顺序
console.log('1. 模块顶层代码');

setImmediate(() => {
  console.log('4. setImmediate');
});

Promise.resolve().then(() => {
  console.log('3. 微任务');
});

process.nextTick(() => {
  console.log('2. nextTick');
});

// 1. 加载太多模块
// 解决：延迟加载
let heavyModule;
function useHeavyModule() {
  if (!heavyModule) {
    heavyModule = require('heavy-module');
  }
  return heavyModule;
}

// 2. 同步I/O操作
// 错误
const config = fs.readFileSync('config.json');

// 正确（如果配置非必需）
let config;
async function getConfig() {
  if (!config) {
    config = JSON.parse(await fs.promises.readFile('config.json'));
  }
  return config;
}

// 3. 大量计算
// 考虑预计算或使用Worker