同步与异步文件操作

在Node.js中，文件操作是日常开发的核心需求之一。同步与异步两种模式的选择直接影响代码的性能和可维护性。理解它们的差异、适用场景以及底层机制，对构建高效应用至关重要。

同步文件操作的特点

同步文件操作会阻塞事件循环，直到操作完成。这种模式代码直观，适合脚本或初始化阶段使用。例如读取配置文件时，后续逻辑可能依赖文件内容，此时同步操作更合理。

const fs = require('fs');

try {
  const data = fs.readFileSync('config.json', 'utf8');
  console.log('配置文件内容:', data);
  // 后续处理逻辑
} catch (err) {
  console.error('读取文件出错:', err);
}

同步操作的典型特征：

• 使用Sync后缀的方法（如readFileSync）
• 通过try-catch处理错误
• 返回值直接包含操作结果

异步文件操作的实现

异步操作通过回调函数、Promise或async/await实现，不会阻塞事件循环。这是Node.js处理I/O的推荐方式，尤其在服务端高并发场景下。

回调函数形式

fs.readFile('data.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log('文件内容:', data);
});
console.log('这行会先执行');

关键点：

• 错误优先的回调约定（第一个参数为error）
• 操作结果通过回调参数传递
• 后续代码会立即执行

Promise形式

现代Node.js支持fs/promises模块：

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

async function processFile() {
  try {
    const data = await fs.readFile('data.csv', 'utf8');
    console.log('CSV内容:', data);
  } catch (err) {
    console.error('处理文件失败:', err);
  }
}
processFile();

优势：

• 避免回调地狱
• 与async/await语法完美配合
• 错误处理更直观

性能对比与底层机制

通过基准测试可以清晰看到差异：

const fs = require('fs');
const largeFile = 'large-video.mp4';

console.time('同步读取');
const syncData = fs.readFileSync(largeFile);
console.timeEnd('同步读取');

console.time('异步读取');
fs.readFile(largeFile, () => {
  console.timeEnd('异步读取');
});

典型测试结果：

• 同步操作：阻塞时间=文件大小/磁盘速度
• 异步操作：调度耗时通常<1ms

底层原理：

• 同步操作直接调用libuv的同步API
• 异步操作使用线程池处理I/O
• 事件循环在等待期间可处理其他任务

错误处理差异

同步操作必须用try-catch：

try {
  fs.writeFileSync('protected/file.txt', 'content');
} catch (err) {
  if (err.code === 'EACCES') {
    console.log('权限不足');
  }
}

异步操作有多种方式：

// 回调方式
fs.unlink('nonexistent.txt', (err) => {
  if (err?.code === 'ENOENT') {
    console.log('文件不存在');
  }
});

// Promise方式
fs.promises.access('locked.file')
  .catch(err => {
    if (err.code === 'EACCES') {
      console.log('访问被拒绝');
    }
  });

混合使用场景

实际开发中常需要组合使用两种模式：

// 启动时同步加载配置
const config = JSON.parse(fs.readFileSync('config.json'));

// 运行时异步处理请求
app.post('/upload', async (req, res) => {
  const chunks = [];
  req.on('data', chunk => chunks.push(chunk));
  req.on('end', async () => {
    await fs.promises.writeFile('upload.data', Buffer.concat(chunks));
    res.sendStatus(200);
  });
});

典型组合场景：

1. 初始化阶段使用同步操作
2. 实时请求处理用异步操作
3. 批处理任务根据复杂度选择

高级模式与流处理

对于大文件操作，流式处理比直接readFile更高效：

const readStream = fs.createReadStream('huge.log');
const writeStream = fs.createWriteStream('filtered.log');

readStream.on('data', chunk => {
  if (chunk.includes('ERROR')) {
    writeStream.write(chunk);
  }
}).on('end', () => {
  writeStream.end();
  console.log('过滤完成');
});

流式处理特点：

• 内存占用恒定
• 支持背压机制
• 可管道化处理（pipe）

文件系统监视

异步API在文件监视中表现出色：

const watcher = fs.watch('dynamic.config', (eventType, filename) => {
  console.log(`检测到${eventType}事件，文件: ${filename}`);
  // 热重载配置
});

process.on('SIGINT', () => {
  watcher.close(); // 需要显式关闭
});

注意事项：

• 不同平台实现有差异
• 需要处理rename事件
• 高频变更可能丢失事件

平台特异性考量

Windows与Unix-like系统的差异：

• 文件路径处理（正反斜杠）
• 权限错误代码不同
• 文件锁定机制差异

跨平台处理示例：

const path = require('path');

const safeWrite = async (file, content) => {
  const dir = path.dirname(file);
  await fs.promises.mkdir(dir, { recursive: true });
  await fs.promises.writeFile(file, content, { mode: 0o644 });
};

调试与性能分析

使用performance hooks监控：

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

const obs = new PerformanceObserver((items) => {
  console.log(items.getEntries()[0].duration);
  performance.clearMarks();
});
obs.observe({ entryTypes: ['measure'] });

performance.mark('fs-start');
fs.readFile('large.bin', () => {
  performance.mark('fs-end');
  performance.measure('文件操作', 'fs-start', 'fs-end');
});

常用优化手段：

• 批量操作使用Promise.all
• 设置适当的缓冲区大小
• 避免频繁的stat检查