如何读取目录并判断文件类型？是否有更高效的实现方式？

Great question! You’re totally right that fs.readdir() only spits back a list of filenames, with no built-in way to tell files apart from folders. Looping through each entry with fs.stat() works, but it’s not the most efficient approach—let’s cover the better alternatives.

1. Use fs.readdir() with the withFileTypes option (Node.js 10.10+) #

This is the most efficient method because it retrieves file type information in a single system call, instead of making separate stat requests for every entry. The callback returns an array of fs.Dirent objects, which have built-in methods to check if an entry is a file, directory, symlink, etc.

Here’s how to implement it:

const fs = require('fs');
const folderName = 'Any_folder_name';

fs.readdir(folderName, { withFileTypes: true }, (err, entries) => {
  if (err) throw err;
  
  // Filter files and directories
  const files = entries.filter(entry => entry.isFile()).map(entry => entry.name);
  const directories = entries.filter(entry => entry.isDirectory()).map(entry => entry.name);
  
  console.log('Files:', files);
  console.log('Directories:', directories);
});

You can also use the promise-based API if you prefer async/await:

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

async function parseDirectory() {
  const entries = await fs.readdir(folderName, { withFileTypes: true });
  
  const files = entries.filter(e => e.isFile()).map(e => e.name);
  const directories = entries.filter(e => e.isDirectory()).map(e => e.name);
  
  console.log('Files:', files);
  console.log('Directories:', directories);
}

parseDirectory().catch(err => console.error(err));

2. Synchronous Version with fs.readdirSync() #

If you need synchronous behavior (e.g., in a script where you don’t want async logic), fs.readdirSync() also supports the withFileTypes option:

const fs = require('fs');
const folderName = 'Any_folder_name';

const entries = fs.readdirSync(folderName, { withFileTypes: true });
const files = entries.filter(e => e.isFile()).map(e => e.name);
const directories = entries.filter(e => e.isDirectory()).map(e => e.name);

console.log('Files:', files);
console.log('Directories:', directories);

3. For Older Node.js Versions (Pre-10.10): Parallelize fs.lstat() Calls #

If you’re stuck on an older Node.js version that doesn’t support withFileTypes, you can improve on sequential stat calls by using Promise.all to run all lstat requests in parallel. This reduces the total time since all I/O operations happen simultaneously instead of one after another.

Note: Use fs.lstat() instead of fs.stat() if you want to detect symlinks (it won’t follow them like stat() does).

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

async function getFilesAndDirectories() {
  const filenames = await fs.readdir(folderName);
  
  // Run all lstat calls in parallel
  const entryDetails = await Promise.all(
    filenames.map(async filename => {
      const fullPath = path.join(folderName, filename);
      const stats = await fs.lstat(fullPath);
      return {
        name: filename,
        isFile: stats.isFile(),
        isDirectory: stats.isDirectory()
      };
    })
  );
  
  const files = entryDetails.filter(item => item.isFile).map(item => item.name);
  const directories = entryDetails.filter(item => item.isDirectory).map(item => item.name);
  
  return { files, directories };
}

// Usage
getFilesAndDirectories()
  .then(result => {
    console.log('Files:', result.files);
    console.log('Directories:', result.directories);
  })
  .catch(err => console.error('Error:', err));

Final Takeaway #

Always prioritize the withFileTypes option if your Node.js version supports it—it’s the fastest, cleanest, and most efficient solution. For older versions, parallelizing lstat calls will give you a significant performance boost over a sequential loop.

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