Node.js API 速览

文档介绍

本文档提供了 Node.js 18+ LTS 版本核心模块的全面 API 参考，旨在帮助开发者快速掌握 Node.js 的核心功能和最佳实践。文档涵盖了文件系统、网络、加密、流等关键模块，并提供了详细的 API 说明和实际使用案例。

模块索引

文件系统 (fs)

模块概述

fs 模块提供了用于与文件系统交互的 API，可以执行文件的读写、创建、删除、重命名等操作。Node.js 18+ 提供了回调式、Promise 式和同步式三种 API 风格。

核心 API

1. 异步文件读取

javascript 
const fs = require('fs/promises');

async function readFileExample() {
  try {
    // 读取文件内容
    const data = await fs.readFile('example.txt', 'utf8');
    console.log('文件内容:', data);
  } catch (error) {
    console.error('读取文件失败:', error);
  }
}

readFileExample();

2. 异步文件写入

javascript 
const fs = require('fs/promises');

async function writeFileExample() {
  try {
    // 写入文件内容
    await fs.writeFile('example.txt', 'Hello, Node.js!', 'utf8');
    console.log('文件写入成功');
  } catch (error) {
    console.error('写入文件失败:', error);
  }
}

writeFileExample();

3. 创建目录

javascript 
const fs = require('fs/promises');

async function mkdirExample() {
  try {
    // 创建目录，支持递归创建
    await fs.mkdir('new-directory', { recursive: true });
    console.log('目录创建成功');
  } catch (error) {
    console.error('创建目录失败:', error);
  }
}

mkdirExample();

4. 文件状态检查

javascript 
const fs = require('fs/promises');

async function statExample() {
  try {
    const stats = await fs.stat('example.txt');
    console.log('文件大小:', stats.size);
    console.log('是否为文件:', stats.isFile());
    console.log('是否为目录:', stats.isDirectory());
    console.log('创建时间:', stats.birthtime);
    console.log('修改时间:', stats.mtime);
  } catch (error) {
    console.error('获取文件状态失败:', error);
  }
}

statExample();

路径处理 (path)

模块概述

path 模块提供了用于处理文件路径和目录路径的实用工具。它可以跨平台工作，自动处理不同操作系统的路径分隔符差异。

核心 API

1. 路径拼接

javascript 
const path = require('path');

// 拼接路径片段
const fullPath = path.join(__dirname, 'files', 'example.txt');
console.log('完整路径:', fullPath);
// 输出: /当前目录/files/example.txt

2. 获取文件名

javascript 
const path = require('path');

const filePath = '/usr/local/bin/node';

// 获取完整文件名
console.log('文件名:', path.basename(filePath)); // 输出: node

// 获取文件名（不包含扩展名）
console.log('文件名(无扩展名):', path.basename(filePath, '.js')); // 输出: node

3. 获取目录名

javascript 
const path = require('path');

const filePath = '/usr/local/bin/node';
console.log('目录名:', path.dirname(filePath)); // 输出: /usr/local/bin

4. 获取扩展名

javascript 
const path = require('path');

const filePath = 'document.pdf';
console.log('扩展名:', path.extname(filePath)); // 输出: .pdf

5. 解析路径

javascript 
const path = require('path');

const filePath = '/usr/local/bin/node';
const parsedPath = path.parse(filePath);

console.log('解析结果:', parsedPath);
/* 输出:
{
  root: '/',
  dir: '/usr/local/bin',
  base: 'node',
  ext: '',
  name: 'node'
}
*/

HTTP 服务器/客户端 (http/https)

模块概述

http 和 https 模块提供了创建 HTTP 和 HTTPS 服务器与客户端的功能。它们是 Node.js 构建 Web 应用的核心模块。

HTTP 服务器

创建简单的 HTTP 服务器

javascript 
const http = require('http');

const hostname = '127.0.0.1';
const port = 3000;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Hello World\n');
});

server.listen(port, hostname, () => {
  console.log(`服务器运行在 http://${hostname}:${port}/`);
});

处理不同请求方法

javascript 
const http = require('http');

const server = http.createServer((req, res) => {
  res.setHeader('Content-Type', 'application/json');
  
  if (req.method === 'GET') {
    res.statusCode = 200;
    res.end(JSON.stringify({ message: 'GET 请求成功' }));
  } else if (req.method === 'POST') {
    let body = '';
    req.on('data', chunk => {
      body += chunk.toString();
    });
    req.on('end', () => {
      res.statusCode = 200;
      res.end(JSON.stringify({ message: 'POST 请求成功', data: JSON.parse(body) }));
    });
  } else {
    res.statusCode = 405;
    res.end(JSON.stringify({ message: '不支持的请求方法' }));
  }
});

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

HTTP 客户端

发送 GET 请求

javascript 
const http = require('http');

http.get('http://localhost:3000', (res) => {
  let data = '';
  
  res.on('data', (chunk) => {
    data += chunk;
  });
  
  res.on('end', () => {
    console.log('响应数据:', JSON.parse(data));
  });
}).on('error', (error) => {
  console.error('请求失败:', error.message);
});

事件机制 (events)

模块概述

events 模块提供了事件驱动的编程模式。通过 EventEmitter 类，开发者可以创建、触发和监听自定义事件。

核心 API

创建和使用 EventEmitter

javascript 
const EventEmitter = require('events');

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

const myEmitter = new MyEmitter();

// 监听事件
myEmitter.on('event', (arg1, arg2) => {
  console.log('事件触发:', arg1, arg2);
});

// 触发事件
myEmitter.emit('event', '参数1', '参数2');

一次性事件监听

javascript 
const EventEmitter = require('events');
const myEmitter = new EventEmitter();

// 一次性事件监听
myEmitter.once('event', () => {
  console.log('这个事件只会触发一次');
});

// 第一次触发
myEmitter.emit('event'); // 输出: 这个事件只会触发一次

// 第二次触发（无输出）
myEmitter.emit('event');

事件监听器数量

javascript 
const EventEmitter = require('events');
const myEmitter = new EventEmitter();

// 添加多个监听器
myEmitter.on('event', () => console.log('监听器1'));
myEmitter.on('event', () => console.log('监听器2'));
myEmitter.on('event', () => console.log('监听器3'));

// 获取监听器数量
console.log('监听器数量:', myEmitter.listenerCount('event')); // 输出: 3

// 获取所有监听器
console.log('所有监听器:', myEmitter.listeners('event'));

流操作 (stream)

模块概述

stream 模块提供了处理流式数据的抽象接口。Node.js 中有四种基本的流类型：Readable（可读流）、Writable（可写流）、Duplex（双向流）和 Transform（转换流）。

核心 API

可读流 (Readable Stream)

javascript 
const fs = require('fs');

// 创建可读流
const readableStream = fs.createReadStream('large-file.txt', 'utf8');

// 监听数据事件
readableStream.on('data', (chunk) => {
  console.log('读取到数据块:', chunk.length);
});

// 监听结束事件
readableStream.on('end', () => {
  console.log('文件读取完毕');
});

// 监听错误事件
readableStream.on('error', (error) => {
  console.error('读取错误:', error);
});

可写流 (Writable Stream)

javascript 
const fs = require('fs');

// 创建可写流
const writableStream = fs.createWriteStream('output.txt');

// 写入数据
writableStream.write('Hello, ');
writableStream.write('Node.js!\n');

// 结束写入
writableStream.end('写入完成');

// 监听完成事件
writableStream.on('finish', () => {
  console.log('写入操作完成');
});

管道流 (Pipeline)

javascript 
const fs = require('fs');
const zlib = require('zlib');

// 使用管道流进行文件压缩
const readableStream = fs.createReadStream('large-file.txt');
const writableStream = fs.createWriteStream('large-file.txt.gz');
const gzip = zlib.createGzip();

// 将流连接起来
readableStream.pipe(gzip).pipe(writableStream);

console.log('文件压缩中...');

二进制数据 (buffer)

模块概述

buffer 模块提供了处理二进制数据的功能。Buffer 类是 Node.js 中用于存储原始二进制数据的全局对象。

核心 API

创建 Buffer

javascript 
// 创建指定大小的 Buffer
const buffer1 = Buffer.alloc(10); // 创建大小为 10 的空 Buffer

// 从数组创建 Buffer
const buffer2 = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]); // 从十六进制数组创建

// 从字符串创建 Buffer
const buffer3 = Buffer.from('Hello, Node.js', 'utf8'); // 从 UTF-8 字符串创建

console.log('Buffer1:', buffer1);
console.log('Buffer2:', buffer2.toString()); // 输出: buffer
console.log('Buffer3:', buffer3.toString()); // 输出: Hello, Node.js

Buffer 操作

javascript 
const buffer1 = Buffer.from('Hello');
const buffer2 = Buffer.from(' World');

// 合并 Buffer
const buffer3 = Buffer.concat([buffer1, buffer2]);
console.log('合并结果:', buffer3.toString()); // 输出: Hello World

// 比较 Buffer
const result = Buffer.compare(buffer1, buffer2);
console.log('比较结果:', result); // 输出: -1 (buffer1 在字典序上小于 buffer2)

// 复制 Buffer
const buffer4 = Buffer.alloc(buffer1.length);
buffer1.copy(buffer4);
console.log('复制结果:', buffer4.toString()); // 输出: Hello

加密功能 (crypto)

模块概述

crypto 模块提供了加密功能，包括密码学哈希、HMAC、加密/解密、数字签名等。

核心 API

1. 生成哈希值

javascript 
const crypto = require('crypto');

// 生成 SHA256 哈希值
const data = 'Hello, Node.js';
const hash = crypto.createHash('sha256');

// 更新哈希内容
hash.update(data);

// 获取哈希值（十六进制格式）
const hexHash = hash.digest('hex');
console.log('SHA256 哈希:', hexHash);
// 输出类似: 315f5bdb76d078c43b8ac0064e4a0164612b1fce77c869345bfc94c75894edd3

2. HMAC 签名

javascript 
const crypto = require('crypto');

const secret = 'my-secret-key';
const data = 'Hello, Node.js';

// 创建 HMAC 对象
const hmac = crypto.createHmac('sha256', secret);

// 更新 HMAC 内容
hmac.update(data);

// 获取 HMAC 值
const hmacValue = hmac.digest('hex');
console.log('HMAC 签名:', hmacValue);

3. 对称加密 (AES)

javascript 
const crypto = require('crypto');

const algorithm = 'aes-256-cbc';
const key = crypto.randomBytes(32); // 256 位密钥
const iv = crypto.randomBytes(16); // 128 位初始化向量

const text = '这是要加密的文本';

// 加密
const cipher = crypto.createCipheriv(algorithm, key, iv);
let encrypted = cipher.update(text, 'utf8', 'hex');
encrypted += cipher.final('hex');
console.log('加密结果:', encrypted);

// 解密
const decipher = crypto.createDecipheriv(algorithm, key, iv);
let decrypted = decipher.update(encrypted, 'hex', 'utf8');
decrypted += decipher.final('utf8');
console.log('解密结果:', decrypted);

工具函数 (util)

模块概述

util 模块提供了一系列实用工具函数，包括类型检查、对象继承、回调转换为 Promise 等。

核心 API

1. 回调转换为 Promise (promisify)

javascript 
const util = require('util');
const fs = require('fs');

// 将回调函数转换为 Promise 形式
const readFilePromise = util.promisify(fs.readFile);

async function readFileExample() {
  try {
    const data = await readFilePromise('example.txt', 'utf8');
    console.log('文件内容:', data);
  } catch (error) {
    console.error('读取失败:', error);
  }
}

readFileExample();

2. 对象继承 (inherits)

javascript 
const util = require('util');
const EventEmitter = require('events');

// 创建自定义类
function MyStream() {
  EventEmitter.call(this);
}

// 继承 EventEmitter 类
util.inherits(MyStream, EventEmitter);

// 添加自定义方法
MyStream.prototype.write = function(data) {
  this.emit('data', data);
};

const stream = new MyStream();

// 监听事件
stream.on('data', (data) => {
  console.log('接收数据:', data);
});

// 触发事件
stream.write('Hello, Node.js');

3. 格式化字符串 (format)

javascript 
const util = require('util');

// 格式化字符串
const formatted = util.format('Hello %s, you are %d years old', 'Alice', 30);
console.log(formatted); // 输出: Hello Alice, you are 30 years old

// 使用占位符
const info = util.format('Error: %O', { code: 404, message: 'Not Found' });
console.log(info); // 输出: Error: { code: 404, message: 'Not Found' }

子进程 (child_process)

模块概述

child_process 模块提供了创建和管理子进程的功能，可以用于执行外部命令或其他 Node.js 脚本。

核心 API

1. 执行外部命令 (exec)

javascript 
const { exec } = require('child_process');

// 执行 ls 命令
exec('ls -la', (error, stdout, stderr) => {
  if (error) {
    console.error(`执行错误: ${error}`);
    return;
  }
  console.log(`标准输出:\n${stdout}`);
  if (stderr) {
    console.error(`标准错误:\n${stderr}`);
  }
});

2. 衍生子进程 (spawn)

javascript 
const { spawn } = require('child_process');

// 衍生 ls 进程
const ls = spawn('ls', ['-la']);

// 监听标准输出
ls.stdout.on('data', (data) => {
  console.log(`标准输出:\n${data}`);
});

// 监听标准错误
ls.stderr.on('data', (data) => {
  console.error(`标准错误:\n${data}`);
});

// 监听进程退出
ls.on('close', (code) => {
  console.log(`子进程退出码: ${code}`);
});

3. 执行 Node.js 脚本 (fork)

javascript 
const { fork } = require('child_process');

// 衍生子进程执行脚本
const child = fork('child.js');

// 向子进程发送消息
child.send({ hello: 'world' });

// 接收子进程消息
child.on('message', (message) => {
  console.log(`父进程接收到: ${message}`);
});

// 监听子进程退出
child.on('exit', (code) => {
  console.log(`子进程退出码: ${code}`);
});

系统信息 (os)

模块概述

os 模块提供了与操作系统交互的功能，可以获取系统信息如 CPU、内存、网络接口等。

核心 API

javascript 
const os = require('os');

// 获取操作系统信息
console.log('操作系统平台:', os.platform());
console.log('操作系统版本:', os.version());
console.log('操作系统类型:', os.type());
console.log('主机名:', os.hostname());
console.log('系统 uptime:', os.uptime());

// 获取 CPU 信息
console.log('CPU 架构:', os.arch());
console.log('CPU 信息:', os.cpus());

// 获取内存信息
console.log('总内存(字节):', os.totalmem());
console.log('可用内存(字节):', os.freemem());

// 获取网络接口
console.log('网络接口:', os.networkInterfaces());

// 获取用户信息
console.log('当前用户:', os.userInfo());

网络基础 (net)

模块概述

net 模块提供了创建 TCP 服务器和客户端的功能，是构建网络应用的基础。

核心 API

创建 TCP 服务器

javascript 
const net = require('net');

const server = net.createServer((socket) => {
  console.log('客户端已连接');
  
  // 发送欢迎消息
  socket.write('欢迎连接到 TCP 服务器！\n');
  
  // 监听数据
  socket.on('data', (data) => {
    console.log(`接收到数据: ${data}`);
    socket.write(`服务器回复: ${data}`);
  });
  
  // 监听连接关闭
  socket.on('end', () => {
    console.log('客户端已断开连接');
  });
});

server.listen(3000, () => {
  console.log('TCP 服务器运行在端口 3000');
});

创建 TCP 客户端

javascript 
const net = require('net');

const client = new net.Socket();

client.connect(3000, '127.0.0.1', () => {
  console.log('已连接到服务器');
  client.write('Hello, Server!');
});

client.on('data', (data) => {
  console.log(`服务器回复: ${data}`);
  // 关闭连接
  client.destroy();
});

client.on('close', () => {
  console.log('连接已关闭');
});

URL 处理 (url)

模块概述

url 模块提供了 URL 解析和处理的功能。Node.js 18+ 推荐使用 WHATWG URL API。

核心 API

javascript 
const { URL } = require('url');

// 创建 URL 对象
const myURL = new URL('https://user:pass@example.com:8080/path/to/resource?query=123#hash');

console.log('协议:', myURL.protocol); // 输出: https:
console.log('用户名:', myURL.username); // 输出: user
console.log('密码:', myURL.password); // 输出: pass
console.log('主机名:', myURL.hostname); // 输出: example.com
console.log('端口:', myURL.port); // 输出: 8080
console.log('路径:', myURL.pathname); // 输出: /path/to/resource
console.log('查询参数:', myURL.search); // 输出: ?query=123
console.log('哈希:', myURL.hash); // 输出: #hash

// 解析查询参数
console.log('查询参数对象:', myURL.searchParams);
console.log('query 参数值:', myURL.searchParams.get('query')); // 输出: 123

// 添加查询参数
myURL.searchParams.append('foo', 'bar');
console.log('更新后的 URL:', myURL.href);

查询字符串 (querystring)

模块概述

querystring 模块提供了处理 URL 查询字符串的功能。

核心 API

javascript 
const querystring = require('querystring');

// 解析查询字符串
const query = 'name=John&age=30&city=New+York';
const parsedQuery = querystring.parse(query);
console.log('解析结果:', parsedQuery);
// 输出: { name: 'John', age: '30', city: 'New York' }

// 序列化对象为查询字符串
const obj = { name: 'John', age: 30, hobbies: ['reading', 'coding'] };
const stringified = querystring.stringify(obj);
console.log('序列化结果:', stringified);
// 输出: name=John&age=30&hobbies=reading&hobbies=coding

// 编码查询字符串
const encoded = querystring.escape('name=John Doe');
console.log('编码结果:', encoded); // 输出: name%3DJohn%20Doe

// 解码查询字符串
const decoded = querystring.unescape(encoded);
console.log('解码结果:', decoded); // 输出: name=John Doe

断言测试 (assert)

模块概述

assert 模块提供了断言测试的功能，用于验证代码的正确性。

核心 API

javascript 
const assert = require('assert');

// 基本断言
assert.strictEqual(1 + 1, 2, '1 + 1 应该等于 2');

// 断言对象相等
const obj1 = { a: 1 };
const obj2 = { a: 1 };
assert.deepStrictEqual(obj1, obj2, '对象应该深度相等');

// 断言条件为真
assert.ok(true, '条件应该为真');

// 断言错误
assert.throws(() => {
  throw new Error('预期的错误');
}, Error, '应该抛出 Error 类型的错误');

// 断言不抛出错误
assert.doesNotThrow(() => {
  return 1 + 1;
}, '不应该抛出错误');

集群管理 (cluster)

模块概述

cluster 模块提供了创建集群的功能，可以充分利用多核 CPU 资源，提高应用性能。

核心 API

javascript 
const cluster = require('cluster');
const os = require('os');
const http = require('http');

if (cluster.isMaster) {
  console.log(`主进程 ${process.pid} 正在运行`);
  
  // 根据 CPU 核心数创建工作进程
  const numCPUs = os.cpus().length;
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
  
  // 监听工作进程退出
  cluster.on('exit', (worker, code, signal) => {
    console.log(`工作进程 ${worker.process.pid} 已退出`);
    // 重启退出的工作进程
    cluster.fork();
  });
} else {
  // 工作进程创建 HTTP 服务器
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end(`响应来自工作进程 ${process.pid}`);
  }).listen(8000);
  
  console.log(`工作进程 ${process.pid} 已启动`);
}

虚拟机 (vm)

模块概述

vm 模块提供了在沙箱环境中执行 JavaScript 代码的功能。

核心 API

javascript 
const vm = require('vm');

// 创建上下文对象
const context = { x: 10, y: 20 };

// 执行脚本
const script = new vm.Script('x + y');
const result = script.runInNewContext(context);
console.log('执行结果:', result); // 输出: 30

// 创建模块
const module = new vm.SourceTextModule(`
  export const hello = 'Hello, Node.js';
  export function add(a, b) {
    return a + b;
  }
`);

// 编译和评估模块
(async () => {
  await module.link(() => {});
  await module.evaluate();
  
  // 获取导出
  const { hello, add } = module.namespace;
  console.log(hello); // 输出: Hello, Node.js
  console.log(add(2, 3)); // 输出: 5
})();

模块系统 (module)

模块概述

module 模块提供了与模块系统交互的功能，允许开发者自定义模块加载行为。

核心 API

javascript 
// module.exports 用于导出模块
module.exports = {
  greet: function(name) {
    return `Hello, ${name}!`;
  },
  add: function(a, b) {
    return a + b;
  }
};

// exports 是 module.exports 的引用
exports.greet = function(name) {
  return `Hello, ${name}!`;
};

// 获取当前模块的目录名
console.log('模块目录:', __dirname);

// 获取当前模块的文件名
console.log('模块文件名:', __filename);

// 模块加载事件
module.on('load', (filename) => {
  console.log(`模块 ${filename} 已加载`);
});

性能监控 (perf_hooks)

模块概述

perf_hooks 模块提供了性能监控的功能，可以用于测量代码执行时间和资源使用情况。

核心 API

javascript 
const { performance, PerformanceObserver } = require('perf_hooks');

// 创建性能观察者
const obs = new PerformanceObserver((items) => {
  console.log('性能测量结果:', items.getEntries()[0]);
  performance.clearMarks();
});
obs.observe({ entryTypes: ['measure'] });

// 开始测量
performance.mark('A');

// 执行一些操作
for (let i = 0; i < 1000000; i++) {
  // 耗时操作
}

// 结束测量
performance.mark('B');
performance.measure('A to B', 'A', 'B');

// 测量异步操作
async function measureAsync() {
  performance.mark('async-start');
  
  // 模拟异步操作
  await new Promise(resolve => setTimeout(resolve, 1000));
  
  performance.mark('async-end');
  performance.measure('async-operation', 'async-start', 'async-end');
}

measureAsync();

UDP 数据报 (dgram)

模块概述

dgram 模块提供了 UDP 数据报套接字的功能，用于创建 UDP 服务器和客户端。

核心 API

创建 UDP 服务器

javascript 
const dgram = require('dgram');

const server = dgram.createSocket('udp4');

server.on('error', (err) => {
  console.error(`服务器错误: ${err.stack}`);
  server.close();
});

server.on('message', (msg, rinfo) => {
  console.log(`服务器收到: ${msg} 来自 ${rinfo.address}:${rinfo.port}`);
  
  // 回复客户端
  server.send('已收到消息', rinfo.port, rinfo.address);
});

server.on('listening', () => {
  const address = server.address();
  console.log(`UDP 服务器正在监听 ${address.address}:${address.port}`);
});

server.bind(41234);

创建 UDP 客户端

javascript 
const dgram = require('dgram');

const client = dgram.createSocket('udp4');

const message = Buffer.from('Hello, UDP Server!');

client.send(message, 41234, 'localhost', (err) => {
  if (err) {
    console.error('发送失败:', err);
    client.close();
  }
  console.log('消息已发送');
});

client.on('message', (msg, rinfo) => {
  console.log(`客户端收到: ${msg} 来自 ${rinfo.address}:${rinfo.port}`);
  client.close();
});

域名解析 (dns)

模块概述

dns 模块提供了域名解析的功能，可以将域名转换为 IP 地址，或将 IP 地址转换为域名。

核心 API

javascript 
const dns = require('dns');

// 解析域名
(async () => {
  try {
    const addresses = await dns.promises.resolve4('www.example.com');
    console.log('IPv4 地址:', addresses);
  } catch (error) {
    console.error('解析失败:', error);
  }
});

// 反向解析 IP 地址
dns.promises.reverse('8.8.8.8')
  .then((hostnames) => {
    console.log('反向解析结果:', hostnames);
  })
  .catch((error) => {
    console.error('反向解析失败:', error);
  });

// 获取 MX 记录
dns.promises.resolveMx('example.com')
  .then((records) => {
    console.log('MX 记录:', records);
  })
  .catch((error) => {
    console.error('获取 MX 记录失败:', error);
  });

压缩解压 (zlib)

模块概述

zlib 模块提供了压缩和解压功能，支持多种压缩格式如 Gzip、Deflate 等。

核心 API

javascript 
const zlib = require('zlib');
const fs = require('fs');

// 文件压缩
const gzip = zlib.createGzip();
const input = fs.createReadStream('large-file.txt');
const output = fs.createWriteStream('large-file.txt.gz');

input.pipe(gzip).pipe(output);
console.log('文件压缩中...');

// 文件解压
const gunzip = zlib.createGunzip();
const compressedInput = fs.createReadStream('large-file.txt.gz');
const decompressedOutput = fs.createWriteStream('decompressed.txt');

compressedInput.pipe(gunzip).pipe(decompressedOutput);
console.log('文件解压中...');

// 字符串压缩和解压
const text = '这是一段需要压缩的文本内容';

zlib.gzip(text, (err, compressed) => {
  if (err) throw err;
  console.log('压缩后:', compressed);
  
  zlib.gunzip(compressed, (err, decompressed) => {
    if (err) throw err;
    console.log('解压后:', decompressed.toString());
  });
});

逐行读取 (readline)

模块概述

readline 模块提供了逐行读取输入的功能，常用于命令行交互和处理文本文件。

核心 API

javascript 
const readline = require('readline');
const fs = require('fs');

// 创建 readline 接口
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

// 命令行交互
rl.question('请输入您的姓名: ', (name) => {
  console.log(`你好, ${name}!`);
  rl.close();
});

// 逐行读取文件
const fileStream = fs.createReadStream('file.txt');
const fileRl = readline.createInterface({
  input: fileStream,
  crlfDelay: Infinity
});

let lineCount = 0;

fileRl.on('line', (line) => {
  lineCount++;
  console.log(`第 ${lineCount} 行: ${line}`);
});

fileRl.on('close', () => {
  console.log(`文件共有 ${lineCount} 行`);
});

其他实用模块

REPL 环境 (repl)

javascript 
const repl = require('repl');

// 创建 REPL 实例
const replServer = repl.start({
  prompt: '> ',
  eval: (cmd, context, filename, callback) => {
    // 自定义求值逻辑
    callback(null, eval(cmd));
  }
});

// 添加自定义命令
replServer.defineCommand('hello', {
  help: '显示欢迎消息',
  action(name) {
    this.clearBufferedCommand();
    console.log(`Hello, ${name || 'world'}!`);
    this.displayPrompt();
  }
});

终端控制 (tty)

javascript 
const tty = require('tty');
const process = require('process');

// 检查是否在终端环境
console.log('标准输入是终端:', tty.isatty(process.stdin.fd));
console.log('标准输出是终端:', tty.isatty(process.stdout.fd));

// 获取终端大小
const size = process.stdout.getWindowSize();
console.log('终端大小:', size);

V8 引擎接口 (v8)

javascript 
const v8 = require('v8');

// 获取堆统计信息
console.log('堆统计信息:', v8.getHeapStatistics());

// 获取堆空间统计信息
console.log('堆空间统计信息:', v8.getHeapSpaceStatistics());

// 序列化对象
const obj = { x: 1, y: 2 };
const serialized = v8.serialize(obj);
console.log('序列化结果:', serialized);

// 反序列化对象
const deserialized = v8.deserialize(serialized);
console.log('反序列化结果:', deserialized);
最后更新：2026-02-07