Node.js中如何使用fs.createWriteStream存储同名同扩展名的多个文件

Great question! This is a super common scenario when handling file uploads, and the fix involves two key steps: checking if the target file already exists, and generating a new filename with an incrementing suffix until you find one that's available. Let's walk through a practical, robust implementation using Node.js's built-in fs and path modules.

Step 1: Split Filename into Name and Extension #

First, we need to reliably separate the base name and file extension (e.g., split image.jpg into image and .jpg). Using Node's path.parse() method avoids manual string splitting errors (like handling filenames with multiple dots, e.g., image.v2.jpg).

Step 2: Check for Existing Files & Generate Candidate Names #

We'll create an async function that loops through candidate filenames, checking if each exists. If it does, we increment the suffix and try again until we find an unused name.

Async Implementation (Recommended for Non-Blocking Code) #

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

async function getAvailableFilename(dir, filename) {
  const { name, ext } = path.parse(filename);
  let candidate = filename;
  let counter = 2;

  while (true) {
    const fullPath = path.join(dir, candidate);
    try {
      // Try to access the file; if it exists, this will throw an error
      await fs.access(fullPath);
      // File exists – generate next candidate
      candidate = `${name}-${counter}${ext}`;
      counter++;
    } catch {
      // File doesn't exist – return this candidate
      return candidate;
    }
  }
}

// Usage example with your upload logic
async function saveUploadedFile(dir, file) {
  const safeFilename = await getAvailableFilename(dir, file.filename);
  const savePath = path.join(dir, safeFilename);
  const writeStream = fs.createWriteStream(savePath);

  // Pipe your incoming file stream to the write stream
  // (adjust this based on your upload setup, e.g., Express multer, etc.)
  file.stream.pipe(writeStream);

  return safeFilename; // Return the final saved filename
}

Sync Implementation (For Blocking Scenarios) #

If you're working in a synchronous context, you can use fs.existsSync() instead:

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

function getAvailableFilenameSync(dir, filename) {
  const { name, ext } = path.parse(filename);
  let candidate = filename;
  let counter = 2;

  while (true) {
    const fullPath = path.join(dir, candidate);
    if (fs.existsSync(fullPath)) {
      candidate = `${name}-${counter}${ext}`;
      counter++;
    } else {
      return candidate;
    }
  }
}

Step 3: Handle Concurrent Uploads (Critical for Production) #

In a production environment, multiple users might upload the same filename at the exact same time. The above code could hit a race condition where two requests both check that image.jpg doesn't exist, then both try to create it. To fix this, use atomic file creation with the wx flag (which fails if the file already exists):

async function getAvailableFilenameAtomic(dir, filename) {
  const { name, ext } = path.parse(filename);
  let candidate = filename;
  let counter = 2;

  while (true) {
    const fullPath = path.join(dir, candidate);
    try {
      // Use 'wx' mode to ensure atomic creation – fails if file exists
      const fileHandle = await fs.open(fullPath, 'wx');
      await fileHandle.close();
      return candidate;
    } catch (err) {
      if (err.code === 'EEXIST') {
        // File exists – try next candidate
        candidate = `${name}-${counter}${ext}`;
        counter++;
      } else {
        // Re-throw other errors (e.g., permission issues)
        throw err;
      }
    }
  }
}

When using this atomic version, you can be confident that no two requests will overwrite each other's files.

Key Notes #

• Always use path.join() to concatenate directories and filenames – it handles cross-platform path separators (e.g., / vs \) automatically, unlike manual string concatenation like ${dir}${file.filename} which can break on Windows.
• If you're using a framework like Express with multer, you can integrate this logic into the storage configuration to handle filenames automatically.

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