Retrieving File Names from Directories in Node.js: A Comprehensive Approach

Introduction

Managing file systems is a common task in programming, and Node.js provides robust tools for interacting with directories on your operating system. This tutorial will guide you through various methods to retrieve the names of files present in a directory using Node.js. We’ll explore synchronous and asynchronous approaches, use third-party libraries for advanced functionality like glob patterns and recursive searches, and implement custom functions to traverse subdirectories.

Using fs.readdir and fs.readdirSync

Node.js’s core fs module offers methods to read directories either synchronously or asynchronously:

• Asynchronous Reading (fs.readdir): This method reads a directory’s contents without blocking the rest of your program. It is suitable for applications where non-blocking operations are critical.

  const fs = require('fs');
  const testFolder = './tests/';
  
  fs.readdir(testFolder, (err, files) => {
    if (err) throw err;
    files.forEach(file => {
      console.log(file);
    });
  });
  

• Synchronous Reading (fs.readdirSync): This method reads a directory’s contents and waits until the operation is complete before moving on. It’s useful when you need to ensure that file reading completes before proceeding with dependent operations.

  const fs = require('fs');
  const testFolder = './tests/';
  
  const files = fs.readdirSync(testFolder);
  files.forEach(file => {
    console.log(file);
  });
  

Filtering Files from Directories

Starting with Node.js v10.10.0, you can use the withFileTypes option to filter out directories and get only file names:

const fs = require('fs');
const path = './dirpath';

const files = fs.readdirSync(path, { withFileTypes: true })
  .filter(item => !item.isDirectory())
  .map(item => item.name);

console.log(files);

Using Glob Patterns with glob and globby

For more complex file matching, glob patterns can be employed. The glob package supports wildcards and other pattern matching techniques.

• Install the glob Package:

  npm install glob
  

• Using glob to Match Files:

  const glob = require('glob');
  
  glob("**/*.js", {}, (err, files) => {
    if (err) throw err;
    console.log(files);
  });
  

• Using globby for Enhanced Pattern Matching:

  First, install globby:

  npm install globby
  

  Then use it to find specific file types:

  const globby = require('globby');
  
  (async () => {
    const files = await globby("**/*.xml");
    console.log(files);
  })();
  

Recursive Directory Traversal

For traversing directories recursively, you can either write a custom function or use a library like node-walk.

• Custom Recursive Function:

  This function will read through all subdirectories and list files.

  const fs = require('fs');
  
  function getFiles(dir) {
    let results = [];
    const files = fs.readdirSync(dir);
  
    for (const file of files) {
      const filePath = `${dir}/${file}`;
      if (fs.statSync(filePath).isDirectory()) {
        results = results.concat(getFiles(filePath));
      } else {
        results.push(filePath);
      }
    }
  
    return results;
  }
  
  console.log(getFiles('path/to/dir'));
  

• Using node-walk for Recursive Search:

  First, install the package:

  npm install walk
  

  Then implement the recursive search:

  const walk = require('walk');
  let files = [];
  
  const walker = walk.walk('./test', { followLinks: false });
  
  walker.on('file', function(root, stat, next) {
    files.push(`${root}/${stat.name}`);
    next();
  });
  
  walker.on('end', function() {
    console.log(files);
  });
  

Conclusion

Node.js provides multiple ways to interact with the file system and retrieve file names from directories. Whether you prefer synchronous or asynchronous operations, use glob patterns for complex matching, or need recursive directory traversal, Node.js has a solution tailored for your needs. Choose the method that best fits your application’s requirements and coding style.