咨询NodeJS等待文件创建及临时文件处理的更优方案

Hey there! Let's break down your current code and fix up those inefficiencies while meeting your core requirements perfectly. First, let's highlight the key issues with your existing implementation:

• Blocking Event Loop: The while (!fs.existsSync(...)) loop is a synchronous blocking operation that will hog your CPU and prevent other asynchronous code (like your setTimeout callbacks) from running. This is a big no-no in Node.js, which relies on non-blocking I/O.
• Overlapping Files: Your current code writes to ./files/file.js for every user—this will overwrite the same file for multiple users, which breaks your "unique temporary file per user" requirement.
• Callback Hell: Nested fs.readFile/fs.writeFile callbacks make the code hard to read and maintain.
• Unreliable Polling: Checking fs.existsSync in a loop is inefficient and unnecessary when you can rely on Node.js's async I/O callbacks/promises to know when the file is ready.

Recommended Solution: Use fs.promises with Async/Await (Non-Blocking, Clean, Efficient) #

This approach uses modern Node.js features to avoid blocking, ensure unique files, and handle the entire flow cleanly:

const fs = require('fs').promises;
const path = require('path');
const crypto = require('crypto'); // For generating unique IDs

// Replace with your actual logger
const logger = {
  error: console.error,
  warn: console.warn
};

async function handleUserTemporaryFile(userId) {
  const filesDir = './files';
  const sourceFilePath = './file.js';

  // Step 1: Ensure the files directory exists (no need to check first—recursive handles it)
  try {
    await fs.mkdir(filesDir, { recursive: true });
  } catch (mkdirErr) {
    logger.error(`Failed to create files directory: ${mkdirErr.message}`);
    return;
  }

  // Step 2: Generate a unique filename for the user (prevents overlaps)
  const uniqueFileId = crypto.randomUUID();
  const tempFilePath = path.join(filesDir, `user_${userId}_temp_${uniqueFileId}.js`);

  try {
    // Step 3: Copy the source file to the unique temp path (more efficient than read + write)
    await fs.copyFile(sourceFilePath, tempFilePath);
    logger.warn(`Successfully created unique temp file for user ${userId}: ${tempFilePath}`);

    // Step 4: Run your one-time business logic NOW that the file is guaranteed to exist
    await runYourBusinessLogic(userId, tempFilePath);

    // Step 5: Clean up the temp file after logic completes
    await fs.unlink(tempFilePath);
    logger.warn(`Cleaned up temp file for user ${userId}: ${tempFilePath}`);
  } catch (err) {
    logger.error(`Error processing temp file for user ${userId}: ${err.message}`);
    // Attempt cleanup even if something fails
    try {
      await fs.unlink(tempFilePath);
    } catch (cleanupErr) {
      logger.error(`Failed to cleanup temp file: ${cleanupErr.message}`);
    }
  }
}

// Example: Your business logic function (replace with your actual code)
async function runYourBusinessLogic(userId, filePath) {
  logger.warn(`Executing business logic for user ${userId} using file: ${filePath}`);
  // Add your code here—file is ready to use!
}

// Usage: Call this function for each user (pass their unique ID)
handleUserTemporaryFile('user_7195739');

Why This Works Better: #

• Non-Blocking: All file operations use async promises, so your event loop stays free to handle other users/requests.
• Guaranteed File Readiness: await fs.copyFile resolves only after the file is fully written to disk—no need to poll!
• Unique Files: Each user gets a unique filename (using their ID + a random UUID) so no overlaps.
• Clean Error Handling: Proper try/catch blocks ensure errors are logged, and we attempt to clean up temp files even if something goes wrong.
• Readable Code: Async/await eliminates callback hell, making the flow easy to follow.

Alternative: File Watcher (For External File Creation) #

If your temp file was being created by an external process (not your own code), you could use fs.watch to listen for its creation. Note: This is unnecessary for your use case (since you're creating the file yourself), but it's good to know:

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

const logger = { error: console.error, warn: console.warn };

function handleExternalTempFile(userId) {
  const filesDir = './files';
  const uniqueFileName = `user_${userId}_temp_${crypto.randomUUID()}.js`;
  const tempFilePath = path.join(filesDir, uniqueFileName);

  // Create directory if needed
  fs.mkdir(filesDir, { recursive: true }, (mkdirErr) => {
    if (mkdirErr) {
      logger.error(`Failed to create directory: ${mkdirErr.message}`);
      return;
    }

    // Watch the directory for new files
    const watcher = fs.watch(filesDir, async (eventType, filename) => {
      if (eventType === 'rename' && filename === uniqueFileName) {
        // File was created!
        logger.warn(`Detected temp file for user ${userId}: ${tempFilePath}`);
        watcher.close(); // Stop watching to avoid duplicate events

        // Run your business logic
        try {
          await runYourBusinessLogic(userId, tempFilePath);
          // Cleanup
          fs.unlink(tempFilePath, (unlinkErr) => {
            if (unlinkErr) logger.error(`Failed to delete file: ${unlinkErr.message}`);
          });
        } catch (err) {
          logger.error(`Business logic failed: ${err.message}`);
        }
      }
    });

    // If you're triggering the file creation elsewhere, do it here
    // ...
  });
}

Key Takeaways from Your Original Code #

• Avoid synchronous fs methods in loops—they block the event loop.
• Always use unique filenames when handling per-user temp files.
• Prefer fs.promises + async/await over nested callbacks for cleaner, more maintainable code.
• Never poll for file existence when you can rely on async I/O completion signals.

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