JavaScript Node.js 内置对象和方法

简介

本文档介绍 Node.js 环境特有的内置对象和方法。这些 API 由 Node.js 运行时提供，不属于 ECMAScript 标准，因此在浏览器中不可用。

参考文档：

• js-builtins.md — ECMAScript 标准内置对象（Math、Date、JSON、Map、Set、Symbol 等）
• js-runtime.md — 浏览器和 Node.js 运行时对比
• js-browser-api.md — 浏览器特有 API（DOM、BOM 等）

全局对象和方法

global — Node.js 全局对象

global 是 Node.js 中的全局对象，类似于浏览器的 window。

console.log(global);        // Global 对象

// 顶层 this 不是 global（模块作用域中）
console.log(this === global);  // false（模块中）
// 在 REPL 中，this === global 为 true

// 全局变量自动成为 global 的属性
global.myVar = 'hello';
console.log(global.myVar);  // "hello"

__filename 和 __dirname

这两个变量仅在 Node.js 模块中可用，表示当前文件的路径信息。

console.log(__filename);  // C:\Users\VanMek\Work\JS\app.js（完整路径）
console.log(__dirname);   // C:\Users\VanMek\Work\JS（所在目录）

process — 进程信息（详细）

process 对象提供当前 Node.js 进程的信息和控制。

// 基本信息
console.log(process.version);     // Node.js 版本，如 "v18.0.0"
console.log(process.versions);    // 所有依赖版本（node、v8、openssl 等）
console.log(process.platform);    // 操作系统平台 "win32"、"linux"、"darwin" 等
console.log(process.arch);        // CPU 架构 "x64"、"arm64" 等

// 命令行参数
console.log(process.argv);  // ['node', 'script.js', ...后续参数]
// 示例：node app.js --name=Alice 123
// process.argv = ['node', 'C:\\...\\app.js', '--name=Alice', '123']

// 环境变量
console.log(process.env.NODE_ENV);  // "development"、"production" 等
process.env.MY_VAR = 'custom';  // 设置环境变量

// 当前工作目录
console.log(process.cwd());  // 当前工作目录路径

// 退出进程
// process.exit(0);  // 0 表示正常退出
// process.exit(1);  // 非 0 表示异常退出

// 标准流
process.stdout.write('输出到标准输出\n');
process.stderr.write('输出到标准错误\n');

// 监听信号
process.on('SIGINT', () => {
  console.log('收到 Ctrl+C，准备退出...');
  process.exit(0);
});

Buffer — 二进制数据处理（ES6）

Buffer 用于处理二进制数据（如文件、网络数据）。

// 创建 Buffer
let buf1 = Buffer.alloc(10);          // 创建 10 字节的 Buffer（已初始化为 0）
let buf2 = Buffer.from('Hello');      // 从字符串创建
let buf3 = Buffer.from([1, 2, 3, 4]);  // 从数组创建

console.log(buf2.toString());  // "Hello"
console.log(buf2.length);       // 5（字节数）

// Buffer 与字符串转换
let str = 'Hello World';
let buf = Buffer.from(str, 'utf8');
console.log(buf);                          // <Buffer 48 65 6c 6c ...>
console.log(buf.toString('utf8'));       // "Hello World"
console.log(buf.toString('hex'));          // "48656c6c6f..."（十六进制）
console.log(buf.toString('base64'));       // "SGVsbG8..."（Base64）

// 拼接 Buffer
let bufA = Buffer.from('Hello ');
let bufB = Buffer.from('World');
let combined = Buffer.concat([bufA, bufB]);
console.log(combined.toString());  // "Hello World"

// 比较 Buffer
let a = Buffer.from('abc');
let b = Buffer.from('abc');
console.log(a.equals(b));  // true

setImmediate 和 clearImmediate

Node.js 特有定时器，在当前事件循环迭代结束后执行。

// setImmediate：当前轮次结束后执行
let imm = setImmediate(() => {
  console.log('立即执行（当前轮次结束后）');
});

// clearImmediate：取消
clearImmediate(imm);

// setImmediate vs setTimeout(fn, 0)
setTimeout(() => console.log('timeout'), 0);
setImmediate(() => console.log('immediate'));
// 两者顺序可能因情况而异

queueMicrotask（ES2020）

将微任务排入队列，在当前任务完成后执行。

console.log('1 - 同步');

queueMicrotask(() => console.log('3 - queueMicrotask'));

Promise.resolve().then(() => console.log('2 - Promise'));

console.log('4 - 同步');
// 输出顺序：1 - 同步 → 4 - 同步 → 2 - Promise → 3 - queueMicrotask

核心模块

Node.js 核心模块在使用前需要用 require() 导入（CommonJS）或 import（ES Modules）。

fs — 文件系统

三种 API 风格

const fs = require('fs');

// 1. 回调风格（传统，不推荐新代码使用）
fs.readFile('file.txt', 'utf8', (err, data) => {
  if (err) return console.error(err);
  console.log(data);
});

// 2. 同步风格（阻塞，适合脚本）
try {
  let data = fs.readFileSync('file.txt', 'utf8');
  console.log(data);
} catch (err) {
  console.error(err);
}

// 3. Promise 风格（推荐，Node.js 10+）
const fsp = require('fs').promises;

async function readFile() {
  try {
    let data = await fsp.readFile('file.txt', 'utf8');
    console.log(data);
  } catch (err) {
    console.error(err);
  }
}

读取文件

const fs = require('fs');

// 异步读取（回调）
fs.readFile('input.txt', 'utf8', (err, data) => {
  if (err) {
    console.error('读取失败:', err.message);
    return;
  }
  console.log('文件内容:', data);
});

// 读取为 Buffer（不指定编码）
fs.readFile('image.png', (err, buffer) => {
  if (err) return console.error(err);
  console.log('Buffer 长度:', buffer.length);
});

// 流式读取（大文件推荐）
let readStream = fs.createReadStream('large-file.txt');
readStream.on('data', (chunk) => {
  console.log('收到数据块:', chunk.length, '字节');
});
readStream.on('end', () => console.log('读取完成'));
readStream.on('error', (err) => console.error(err));

写入文件

const fs = require('fs');

// 异步写入
fs.writeFile('output.txt', 'Hello Node.js!\n', (err) => {
  if (err) return console.error(err);
  console.log('写入成功');
});

// 同步写入
try {
  fs.writeFileSync('output.txt', 'Hello Sync!\n');
  console.log('写入成功');
} catch (err) {
  console.error(err);
}

// 追加写入
fs.appendFile('log.txt', '新的一行\n', (err) => {
  if (err) console.error(err);
});

// 流式写入
let writeStream = fs.createWriteStream('output.txt');
writeStream.write('第一行\n');
writeStream.write('第二行\n');
writeStream.end();  // 结束写入
writeStream.on('finish', () => console.log('写入完成'));

目录操作

const fs = require('fs');
const fsp = fs.promises;

// 读取目录
fs.readdir('.', (err, files) => {
  if (err) return console.error(err);
  console.log('目录内容:', files);
});

// 创建目录
fs.mkdir('new-dir', { recursive: true }, (err) => {
  if (err) return console.error(err);
  console.log('目录创建成功');
});

// 删除文件
fs.unlink('file.txt', (err) => {
  if (err) return console.error(err);
  console.log('文件删除成功');
});

// 删除目录
fs.rmdir('empty-dir', (err) => {
  if (err) return console.error(err);
  console.log('目录删除成功');
});

// 递归删除（Node.js 12+）
fs.rm('dir-with-content', { recursive: true, force: true }, (err) => {
  if (err) return console.error(err);
  console.log('递归删除成功');
});

文件信息

const fs = require('fs');

// 获取文件状态
fs.stat('file.txt', (err, stats) => {
  if (err) return console.error(err);

  console.log('是文件:', stats.isFile());
  console.log('是目录:', stats.isDirectory());
  console.log('大小:', stats.size, '字节');
  console.log('创建时间:', stats.birthtime);
  console.log('修改时间:', stats.mtime);
});

// 检查文件是否存在（不推荐，存在竞态条件）
fs.access('file.txt', fs.constants.F_OK, (err) => {
  console.log('文件存在:', !err);
});

// 更好的方式：使用 fs.existsSync（同步）
if (fs.existsSync('file.txt')) {
  console.log('文件存在');
}

文件监视

const fs = require('fs');

// 监视文件变化
let watcher = fs.watch('file.txt', (eventType, filename) => {
  console.log('事件类型:', eventType);  // 'rename' 或 'change'
  console.log('文件名:', filename);
});

// 一段时间后停止监视
setTimeout(() => {
  watcher.close();
  console.log('停止监视');
}, 10000);

path — 路径处理

path 模块用于处理文件路径，自动处理不同操作系统的路径分隔符。

const path = require('path');

// 路径拼接（推荐，自动处理分隔符）
console.log(path.join('/users', 'alice', 'documents'));  // \users\alice\documents（Windows）
console.log(path.join('dir', '..', 'other'));             // other（处理 ..）

// 解析为绝对路径
console.log(path.resolve('file.txt'));           // 基于当前工作目录的绝对路径
console.log(path.resolve('/dir', 'file.txt'));    // C:\dir\file.txt（Windows）

// 解析路径各部分
let filePath = '/users/alice/documents/file.txt';
console.log(path.basename(filePath));   // "file.txt"（文件名）
console.log(path.dirname(filePath));    // "/users/alice/documents"（目录）
console.log(path.extname(filePath));    // ".txt"（扩展名）
console.log(path.parse(filePath));      // { root: '/', dir: '/users/alice/documents', base: 'file.txt', ext: '.txt', name: 'file' }

// 从对象还原路径
console.log(path.format({
  dir: '/users/alice',
  base: 'file.txt'
}));  // "/users/alice/file.txt"

// 相对路径
console.log(path.relative('/a/b/c', '/a/d'));  // "..\..\d"

// 平台特定分隔符
console.log(path.sep);       // Windows: \  Linux/Mac: /
console.log(path.delimiter); // Windows: ;  Linux/Mac: :

http/https — HTTP 服务器和客户端

创建 HTTP 服务器

const http = require('http');

const server = http.createServer((req, res) => {
  // req：请求对象
  // res：响应对象

  console.log('请求方法:', req.method);   // GET、POST 等
  console.log('请求 URL:', req.url);
  console.log('请求头:', req.headers);

  // 设置响应头
  res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });

  // 发送响应
  res.end('Hello from Node.js HTTP Server!');
});

server.listen(3000, () => {
  console.log('服务器运行在 http://localhost:3000');
});

处理不同类型的请求

const http = require('http');
const url = require('url');

const server = http.createServer((req, res) => {
  let parsedUrl = url.parse(req.url, true);
  let pathname = parsedUrl.pathname;
  let query = parsedUrl.query;

  if (pathname === '/') {
    res.writeHead(200, { 'Content-Type': 'text/html' });
    res.end('<h1>首页</h1>');
  }
  else if (pathname === '/api/users') {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify([{ id: 1, name: 'Alice' }]));
  }
  else if (pathname === '/form' && req.method === 'POST') {
    let body = '';
    req.on('data', chunk => body += chunk);
    req.on('end', () => {
      res.writeHead(200);
      res.end('收到数据: ' + body);
    });
  }
  else {
    res.writeHead(404);
    res.end('404 Not Found');
  }
});

server.listen(3000);

HTTP 客户端请求

const https = require('https');

// GET 请求
https.get('https://api.example.com/data', (res) => {
  let data = '';
  res.on('data', chunk => data += chunk);
  res.on('end', () => {
    console.log('响应:', data);
  });
}).on('error', (err) => {
  console.error('请求失败:', err);
});

// POST 请求
const http = require('http');
let postData = JSON.stringify({ name: 'Alice', age: 25 });

let options = {
  hostname: 'api.example.com',
  port: 80,
  path: '/users',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(postData)
  }
};

let req = http.request(options, (res) => {
  let data = '';
  res.on('data', chunk => data += chunk);
  res.on('end', () => console.log('响应:', data));
});

req.on('error', (err) => console.error(err));
req.write(postData);
req.end();

os — 操作系统信息

const os = require('os');

// 系统信息
console.log('平台:', os.platform());     // "win32"、"linux" 等
console.log('架构:', os.arch());        // "x64"、"arm64" 等
console.log('CPU 信息:', os.cpus());     // CPU 核心信息数组
console.log('总内存:', os.totalmem());   // 总内存（字节）
console.log('空闲内存:', os.freemem());  // 空闲内存（字节）
console.log('主目录:', os.homedir());    // 用户主目录
console.log('临时目录:', os.tmpdir());   // 系统临时目录
console.log('主机名:', os.hostname());   // 计算机名
console.log('系统运行时间:', os.uptime()); // 系统运行秒数

// 网络接口
let interfaces = os.networkInterfaces();
console.log(interfaces);

crypto — 加密

哈希（Hash）

const crypto = require('crypto');

// 计算 MD5（不推荐用于安全场景）
let hash = crypto.createHash('md5');
hash.update('Hello World');
console.log(hash.digest('hex'));  // MD5 哈希（十六进制）

// 计算 SHA-256（推荐）
let sha256 = crypto.createHash('sha256');
sha256.update('Hello World');
console.log(sha256.digest('hex'));  // SHA-256 哈希

// 一次性计算
let hash2 = crypto.createHash('sha256').update('Hello').digest('hex');
console.log(hash2);

HMAC（基于哈希的消息认证码）

const crypto = require('crypto');

// 创建 HMAC
let hmac = crypto.createHmac('sha256', 'secret-key');
hmac.update('Hello World');
console.log(hmac.digest('hex'));  // HMAC-SHA256

// 验证（对方用相同密钥计算后比较）

随机数

const crypto = require('crypto');

// 生成随机字节
crypto.randomBytes(16, (err, buf) => {
  if (err) return console.error(err);
  console.log(buf.toString('hex'));  // 32 个十六进制字符
});

// 同步版本
try {
  let buf = crypto.randomBytesSync(16);
  console.log(buf.toString('hex'));
} catch (err) {
  console.error(err);
}

// 生成 UUID（Node.js 14.17+）
let uuid = crypto.randomUUID();
console.log(uuid);  // 如 "550e8400-e29b-41d4-a716-446655440000"

加密和解密（AES）

const crypto = require('crypto');

// AES-256-CBC 加密
function encrypt(text, key, iv) {
  let cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
  let encrypted = cipher.update(text, 'utf8', 'hex');
  encrypted += cipher.final('hex');
  return encrypted;
}

// 解密
function decrypt(encrypted, key, iv) {
  let decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
  let decrypted = decipher.update(encrypted, 'hex', 'utf8');
  decrypted += decipher.final('utf8');
  return decrypted;
}

// 使用
let key = crypto.randomBytesSync(32);  // 256 位密钥
let iv = crypto.randomBytesSync(16);   // 初始化向量
let encrypted = encrypt('Hello World', key, iv);
console.log('加密:', encrypted);
console.log('解密:', decrypt(encrypted, key, iv));

events — 事件触发器

events 模块是 Node.js 事件驱动架构的基础。

const EventEmitter = require('events');

// 创建事件发射器
class MyEmitter extends EventEmitter {}

let emitter = new MyEmitter();

// 监听事件
emitter.on('message', (data) => {
  console.log('收到消息:', data);
});

// 触发事件
emitter.emit('message', 'Hello!');  // 输出：收到消息: Hello!

// once：只监听一次
emitter.once('connect', () => {
  console.log('连接建立（仅一次）');
});
emitter.emit('connect');  // 触发
emitter.emit('connect');  // 不触发（已移除）

// 移除监听
function handler(data) { console.log(data); }
emitter.on('data', handler);
emitter.emit('data', 'Hello');
emitter.removeListener('data', handler);  // 移除特定监听
// emitter.removeAllListeners('message');  // 移除所有 message 监听

url — URL 处理

WHATWG URL 标准（推荐）

const { URL, URLSearchParams } = require('url');

// 解析 URL
let myUrl = new URL('https://example.com:8080/path?name=Alice&age=25#section');
console.log(myUrl.href);       // 完整 URL
console.log(myUrl.protocol);  // "https:"
console.log(myUrl.host);       // "example.com:8080"
console.log(myUrl.hostname);   // "example.com"
console.log(myUrl.port);       // "8080"
console.log(myUrl.pathname);   // "/path"
console.log(myUrl.search);     // "?name=Alice&age=25"
console.log(myUrl.hash);       // "#section"

// 修改 URL
myUrl.pathname = '/new-path';
myUrl.searchParams.set('sort', 'name');
console.log(myUrl.href);

// URLSearchParams：操作查询字符串
let params = new URLSearchParams('?name=Alice&age=25');
console.log(params.get('name'));   // "Alice"
console.log(params.has('age'));    // true
params.append('city', 'Beijing');
console.log(params.toString());     // "name=Alice&age=25&city=Beijing"

旧版 url.parse（已废弃，了解即可）

const url = require('url');

// 不推荐使用，仅作了解
let parsed = url.parse('https://example.com/path?q=hello', true);
console.log(parsed.pathname);  // "/path"
console.log(parsed.query);     // { q: 'hello' }

util — 工具函数

const util = require('util');

// promisify：将回调风格函数转为 Promise 风格
const fs = require('fs');
const readFileAsync = util.promisify(fs.readFile);

readFileAsync('file.txt', 'utf8')
  .then(data => console.log(data))
  .catch(err => console.error(err));

// format：格式化字符串（类似 printf）
console.log(util.format('%s:%s', 'name', 'Alice'));  // "name:Alice"
console.log(util.format('%d + %d = %d', 1, 2, 1 + 2));  // "1 + 2 = 3"

// inspect：对象转字符串（用于调试）
let obj = { name: 'Alice', age: 25, greet() { console.log('hi'); } };
console.log(util.inspect(obj, { depth: null, colors: true }));

// types：类型检查（Node.js 10+）
console.log(util.types.isDate(new Date()));        // true
console.log(util.types.isRegExp(/ab+c/));       // true
console.log(util.types.isPromise(Promise.resolve())); // true

child_process — 子进程（简要）

const { exec, spawn, fork } = require('child_process');

// exec：执行命令，获取完整输出
exec('dir', (err, stdout, stderr) => {
  if (err) return console.error(stderr);
  console.log(stdout);  // 命令输出
});

// spawn：流式处理输出（适合长时间运行的命令）
let child = spawn('node', ['script.js']);
child.stdout.on('data', (data) => console.log(`输出: ${data}`));
child.stderr.on('data', (data) => console.error(`错误: ${data}`));
child.on('close', (code) => console.log(`子进程退出，码: ${code}`));

// fork：创建新的 Node.js 进程（可通信）
let child = fork('child-script.js');
child.on('message', (msg) => console.log('来自子进程:', msg));
child.send({ type: 'start', data: 'Hello' });

stream — 流（简要）

const fs = require('fs');

// 管道：读取流 → 写入流
let readStream = fs.createReadStream('input.txt');
let writeStream = fs.createWriteStream('output.txt');
readStream.pipe(writeStream);

// 链式管道处理
const { createGzip } = require('zlib');
fs.createReadStream('input.txt')
  .pipe(createGzip())
  .pipe(fs.createWriteStream('input.txt.gz'));

// 自定义可读流
const { Readable } = require('stream');
let readable = new Readable({
  read() {
    this.push('Hello');
    this.push('World');
    this.push(null);  // 结束
  }
});
readable.on('data', (chunk) => console.log(chunk.toString()));

net — 网络（简要）

const net = require('net');

// TCP 服务器
let server = net.createServer((socket) => {
  console.log('客户端连接:', socket.remoteAddress);

  socket.on('data', (data) => {
    console.log('收到:', data.toString());
    socket.write('已收到: ' + data);
  });

  socket.on('end', () => {
    console.log('客户端断开');
  });
});

server.listen(8124, () => console.log('TCP 服务器监听 8124'));

// TCP 客户端
let client = net.connect(8124, () => {
  client.write('Hello Server!');
});

client.on('data', (data) => {
  console.log('服务器回复:', data.toString());
  client.end();
});

模块系统

CommonJS（传统方式）

// math.js — 导出模块
function add(a, b) {
  return a + b;
}

function subtract(a, b) {
  return a - b;
}

// 方式 1：module.exports（推荐）
module.exports = { add, subtract };

// 方式 2：exports（注意不能重新赋值）
exports.multiply = (a, b) => a * b;

// app.js — 导入模块
const math = require('./math.js');
console.log(math.add(2, 3));       // 5
console.log(math.subtract(5, 3));  // 2
console.log(math.multiply(3, 4));  // 12

// 导入内置模块
const fs = require('fs');
const path = require('path');

ES Modules（现代方式）

// package.json 中设置 "type": "module"，或使用 .mjs 扩展名

// math.mjs — 导出
export function add(a, b) {
  return a + b;
}

export function subtract(a, b) {
  return a - b;
}

export default function multiply(a, b) {  // 默认导出
  return a * b;
}

// app.mjs — 导入
import { add, subtract } from './math.mjs';
import multiply from './math.mjs';  // 默认导入

console.log(add(2, 3));       // 5
console.log(multiply(3, 4));  // 12

综合示例

示例 1：文件处理脚本

const fs = require('fs').promises;
const path = require('path');

async function processFiles(dirPath) {
  try {
    let files = await fs.readdir(dirPath);
    console.log(`目录 ${dirPath} 中有 ${files.length} 个文件:`);

    for (let file of files) {
      let filePath = path.join(dirPath, file);
      let stats = await fs.stat(filePath);

      if (stats.isFile()) {
        let sizeKB = (stats.size / 1024).toFixed(2);
        console.log(`  ${file} — ${sizeKB} KB`);
      } else if (stats.isDirectory()) {
        console.log(`  [目录] ${file}`);
      }
    }
  } catch (err) {
    console.error('处理失败:', err.message);
  }
}

// processFiles('./');

示例 2：简单的 HTTP API 服务器

const http = require('http');
const url = require('url');

let users = [
  { id: 1, name: 'Alice', age: 25 },
  { id: 2, name: 'Bob', age: 30 }
];

let server = http.createServer((req, res) => {
  let parsedUrl = url.parse(req.url, true);
  let pathname = parsedUrl.pathname;

  // 设置 CORS 头
  res.setHeader('Access-Control-Allow-Origin', '*');
  res.setHeader('Content-Type', 'application/json');

  if (pathname === '/api/users' && req.method === 'GET') {
    res.writeHead(200);
    res.end(JSON.stringify(users));
  }
  else if (pathname === '/api/users' && req.method === 'POST') {
    let body = '';
    req.on('data', chunk => body += chunk);
    req.on('end', () => {
      let newUser = JSON.parse(body);
      newUser.id = users.length + 1;
      users.push(newUser);
      res.writeHead(201);
      res.end(JSON.stringify(newUser));
    });
  }
  else if (pathname.startsWith('/api/users/')) {
    let id = parseInt(pathname.split('/')[3]);
    let user = users.find(u => u.id === id);

    if (user) {
      res.writeHead(200);
      res.end(JSON.stringify(user));
    } else {
      res.writeHead(404);
      res.end(JSON.stringify({ error: '用户未找到' }));
    }
  }
  else {
    res.writeHead(404);
    res.end(JSON.stringify({ error: '路由未找到' }));
  }
});

server.listen(3000, () => console.log('API 服务器运行在 http://localhost:3000'));

示例 3：事件驱动编程

const EventEmitter = require('events');

class TaskQueue extends EventEmitter {
  constructor() {
    super();
    this.tasks = [];
    this.isProcessing = false;
  }

  addTask(task) {
    this.tasks.push(task);
    this.emit('taskAdded', task);
    if (!this.isProcessing) {
      this.processNext();
    }
  }

  async processNext() {
    if (this.tasks.length === 0) {
      this.emit('allDone');
      return;
    }

    this.isProcessing = true;
    let task = this.tasks.shift();
    this.emit('taskStart', task);

    try {
      let result = await task();
      this.emit('taskComplete', { task, result });
    } catch (err) {
      this.emit('taskError', { task, error: err.message });
    }

    this.processNext();
  }
}

// 使用
let queue = new TaskQueue();

queue.on('taskAdded', (task) => console.log('添加任务'));
queue.on('taskComplete', ({ result }) => console.log('完成:', result));
queue.on('allDone', () => console.log('所有任务完成'));

queue.addTask(() => new Promise(resolve => setTimeout(() => resolve('Task 1'), 1000)));
queue.addTask(() => new Promise(resolve => setTimeout(() => resolve('Task 2'), 500)));

示例 4：文件哈希计算

const crypto = require('crypto');
const fs = require('fs');

function calculateFileHash(filePath, algorithm = 'sha256') {
  return new Promise((resolve, reject) => {
    let hash = crypto.createHash(algorithm);
    let stream = fs.createReadStream(filePath);

    stream.on('data', chunk => hash.update(chunk));
    stream.on('end', () => resolve(hash.digest('hex')));
    stream.on('error', reject);
  });
}

// 使用
// calculateFileHash('test.txt').then(hash => console.log('SHA-256:', hash));
// calculateFileHash('test.txt', 'md5').then(hash => console.log('MD5:', hash));

总结：Node.js 核心 API 速查表

重要提示：本文档介绍的是 Node.js 特有 API。ECMAScript 标准内置对象（Math、Date、JSON、Map、Set、Promise 等）请参考 js-builtins.md。