Node.js代码偶发报错求助：数组含undefined且文件被WebSocket更新

这问题我之前处理类似高频文件更新场景时碰到过！核心原因确实是文件写入（WebSocket更新）和读取操作的竞态条件——当你的代码正在读取文件的同时，WebSocket那边正在写入，导致读到了不完整的JSON数据，解析后就出现了随机位置的undefined。下面给你几个靠谱的解决办法：

1. 用临时文件原子替换（推荐，无需额外依赖） #

WebSocket更新文件时，先写入一个临时文件，等写入完成后再用原子操作替换原文件。因为大多数操作系统的文件重命名是原子性的，读取时要么拿到完整的旧文件，要么拿到完整的新文件，不会出现中间的不完整状态。

示例代码：

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

async function updateChartFile(symbol, newData) {
  const filePath = `charts/${symbol}.json`;
  const tmpFilePath = `charts/${symbol}.tmp.json`;
  
  // 先写入临时文件，确保数据完整
  await fs.writeFile(tmpFilePath, JSON.stringify(newData), 'utf8');
  // 原子替换原文件，这一步是瞬间完成的
  await fs.rename(tmpFilePath, filePath);
}

2. 维护内存缓存+按需持久化（性能最优） #

既然WebSocket是持续更新数据，不如直接把数据存在内存里，读取操作直接从内存拿，完全绕开文件IO的竞态问题。只有需要持久化的时候，再定期把内存数据写入文件（比如延迟几秒批量写入，避免频繁写文件）。

示例代码：

const fs = require('fs').promises;
// 用Map维护不同symbol的图表数据缓存
const chartDataCache = new Map();

// WebSocket更新时直接修改内存缓存
function onWebSocketUpdate(symbol, newData) {
  chartDataCache.set(symbol, newData);
  
  // 延迟1秒写入文件，合并短时间内的多次更新
  clearTimeout(global[`persistTimer_${symbol}`]);
  global[`persistTimer_${symbol}`] = setTimeout(async () => {
    await fs.writeFile(`charts/${symbol}.json`, JSON.stringify(newData), 'utf8');
  }, 1000);
}

// 读取时直接从缓存获取，无文件IO开销
function getChartData(symbol) {
  // 没有缓存的话返回空数组兜底
  return chartDataCache.get(symbol) || [];
}

// 服务启动时从文件加载数据到缓存（避免重启丢失数据）
async function initCache() {
  // 这里可以遍历charts目录下的json文件，加载到cache里
  // 示例：
  const symbol = 'BTC';
  try {
    const data = await fs.readFile(`charts/${symbol}.json`, 'utf8');
    chartDataCache.set(symbol, JSON.parse(data));
  } catch (err) {
    chartDataCache.set(symbol, []);
  }
}
initCache();

3. 使用文件锁机制 #

借助文件锁库（比如lockfile），确保同一时间只有一个操作在读写目标文件。读取和写入操作都要先获取锁，操作完成后释放锁，避免竞态。

示例代码：

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

// 带锁的读取函数
async function readChartFile(symbol) {
  const filePath = `charts/${symbol}.json`;
  const lockPath = `${filePath}.lock`;
  
  try {
    // 等待锁释放，最多等待500ms，超时则抛出错误
    await lockfile.lock(lockPath, { wait: 500 });
    const data = await fs.readFile(filePath, 'utf8');
    return JSON.parse(data);
  } finally {
    // 不管成功失败都释放锁，避免死锁
    await lockfile.unlock(lockPath).catch(() => {});
  }
}

// 带锁的写入函数（WebSocket更新逻辑也要用这个）
async function writeChartFile(symbol, newData) {
  const filePath = `charts/${symbol}.json`;
  const lockPath = `${filePath}.lock`;
  
  try {
    await lockfile.lock(lockPath, { wait: 500 });
    await fs.writeFile(filePath, JSON.stringify(newData), 'utf8');
  } finally {
    await lockfile.unlock(lockPath).catch(() => {});
  }
}

4. 读取时校验+重试（兜底方案） #

如果以上方案暂时没法落地，可以在读取后校验JSON的完整性，解析失败或数组存在undefined时重试几次，作为临时过渡方案。

示例代码：

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

async function readChartFileWithRetry(symbol, maxRetry = 3) {
  const filePath = `charts/${symbol}.json`;
  
  for (let i = 0; i < maxRetry; i++) {
    try {
      const data = await fs.readFile(filePath, 'utf8');
      const parsedData = JSON.parse(data);
      
      // 额外校验数组是否存在undefined
      if (Array.isArray(parsedData) && !parsedData.includes(undefined)) {
        return parsedData;
      }
    } catch (err) {
      // 解析失败，等待100ms后重试
      await new Promise(resolve => setTimeout(resolve, 100));
    }
  }
  
  // 多次重试失败，返回空数组兜底
  return [];
}

方案优先级建议 #

优先选内存缓存+按需持久化（性能最高，彻底解决竞态）或临时文件原子替换（无需额外依赖，稳定性强），文件锁方案适合必须直接读写文件的场景，校验重试只适合临时过渡。

内容的提问来源于stack exchange，提问作者tel90