Node.js如何编写正确的递归异步函数？文件搜索程序改造求助

Hey there! Let’s fix up your asynchronous file search script step by step. Your original synchronous approach works, but asynchronous code in Node.js requires handling async operations properly (no premature returns, using promises/async/await) to avoid race conditions and collect results correctly.

What’s Wrong with Your Current Code #

• Premature Return: getFiles returns fileList immediately, before the fs.readdir callback runs. Since readdir is asynchronous, the array is still empty when you log it.
• Broken Recursion: Using return getFiles(...) inside the loop stops the iteration after the first directory, and you don’t collect the results from recursive calls.
• Mixed Sync/Async: You’re using asynchronous readdir but synchronous lstatSync—it’s better to keep everything async to avoid blocking the event loop.
• Unfinished Async Check: Your checkString function would likely block if using synchronous file reads; we need an async version of that too.

Solution: Async/Await Implementation #

We’ll use Node.js’s built-in fs.promises (available in Node 10+) for promise-based file system operations, paired with async/await to write clean, readable asynchronous code.

// Get needed arguments for running the script
// USAGE: node search [EXT] [TEXT]
const args = process.argv.slice(2);
const fs = require('fs').promises;
const path = require('path');

// Validate input
if (!args[0] || !args[1]) {
    console.log("USAGE: node search [EXT] [TEXT]");
    process.exit(1);
}

const targetExt = args[0];
const targetWord = args[1];
const startPath = process.cwd();

// Async function to recursively search files
async function searchFiles(currentPath) {
    let matchingFiles = [];
    const items = await fs.readdir(currentPath);

    for (const item of items) {
        const itemPath = path.join(currentPath, item);
        const stats = await fs.lstat(itemPath);

        if (stats.isDirectory()) {
            // Recursively search subdirectories and merge results
            const subDirMatches = await searchFiles(itemPath);
            matchingFiles = matchingFiles.concat(subDirMatches);
        } else {
            // Check if file has the target extension
            if (item.endsWith(targetExt)) {
                // Read file content and check for target word
                const content = await fs.readFile(itemPath, 'utf8');
                if (content.includes(targetWord)) {
                    matchingFiles.push(itemPath);
                }
            }
        }
    }

    return matchingFiles;
}

// Run the search and handle results
searchFiles(startPath)
    .then((results) => {
        console.log('Files containing the target word:');
        console.log(results);
        console.log("end");
    })
    .catch((err) => {
        console.error('Error during search:', err);
    });

Key Improvements #

• Async/Await: Makes asynchronous code read like synchronous code, avoiding callback hell.
• Promise-Based FS API: fs.promises returns promises for all file operations, which works seamlessly with await.
• Proper Recursion Handling: We wait for recursive directory searches and merge their results into the main array.
• Path Safety: Using path.join ensures correct path formatting across Windows, macOS, and Linux.
• Error Handling: Added a .catch() block to handle any file system errors (e.g., permission issues).
• Clean Result Collection: The function returns a promise that resolves to the full list of matching files once all operations are done.

How to Use #

Run it exactly like your original script:

node search .txt "your-search-word"

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