为什么我不能在数组中推送文件？

Question

I have a function for recursively finding files. if type D is specified, I want only folders to be added to the array. and if type F then only files. It works fine with file search. but if type D then nothing can be added although it is possible to output to the console. Why can't I add to the array and how can I fix it

const type = T or D

const walk = (dir, done) => {
    let results = [];
    return new Promise((resolve, reject) => {
        fs.readdir(dir, (err, list) => {
            if (err) return done(err);
            let pending = list.length;
            if (!pending) return done(null, results);
            list.forEach((file) => {
                file = path.join(dir, file);
                fs.stat(file, function (err, stat) {
                    if (stat && stat.isDirectory()) {
                        if (type && type === 'D') {
                            console.log(file)
                            results.push(file);
                        }
                        walk(file, (err, res) => {
                            results.push(...res);
                            if (!--pending) done(null, results);
                        });
                    } else {
                        if (type === 'F') {
                            results.push(file);
                            if (!--pending) done(null, results);
                        }
                    }
                });
            });
        });
    })
};

walk(baseDir, (err, results) => {
    if (err) throw err;
    console.log(results);
});

Answer 1

When type is D , you're currently decrementing pending only inside the if (stat && stat.isDirectory()) block, but pending 's amount also depends on the number of files in the directory, due to let pending = list.length; .

One way to fix it would be to decrement pending inside the else regardless:

} else {
    if (type === 'F') {
        results.push(file);
    }
    if (!--pending) done(null, results);
}

Or, to be cleaner and avoid some of the callback hell, use async functions and await instead, and then you can use Promise.all instead of manually checking indicies (which is tedious and can be error-prone). This also makes the function return a Promise properly (when done isn't passed):

const walk = async (dir, done) => {
    try {
        const list = await readdir(dir);
        const resultsArr = await Promise.all(list.map(async (fileName) => {
            const filePath = path.join(dir, fileName);
            const stats = await stat(filePath);
            if (stats.isDirectory()) {
                if (type === 'D') {
                    return [filePath, ...await walk(filePath)];
                }
                return walk(filePath);
            } else if (!stats.isDirectory() && type === 'F') {
                return filePath;
            }
        }));
        const flatResults = resultsArr.flat().filter(Boolean);
        if (done) {
            done(null, flatResults);
        }
        return flatResults;
    } catch (err) {
        if (done) {
            done(err);
        } else {
            throw err;
        }
    }
};