Node.js Working with Folders

In any backend application, managing the file system is a fundamental task. Node.js provides the built-in fs (File System) module, which acts as a powerful toolkit for interacting with directories. Whether you are building a system to organize user-uploaded images, generating automated reports, or managing temporary log files, understanding how to programmatically create, read, and delete folders is essential.

Key Features of Working with Folders

1. Creating Directories: You can generate new folders on the fly. This is particularly useful for organizing data by date or user ID.
2. Reading Directories: This allows you to "scan" a folder to see what files or sub-folders exist inside it, similar to opening a folder in your OS file explorer.
3. Removing Directories: You can clean up your workspace by removing empty or non-empty directories when they are no longer needed.
4. Directory Information: Before performing an action, you can check if a folder exists or retrieve its metadata (like creation date).

Creating Directories

1. fs.mkdir()

The fs.mkdir() (make directory) method is asynchronous. It tells Node.js to start creating a folder and move on to the next line of code immediately. Once the folder is actually created, a callback function runs to handle the result.

const fs = require('fs');

fs.mkdir('logs', (err) => {
  if (err) {
    return console.error('Could not create directory:', err.message);
  }
  console.log('Directory created successfully!');
});

Output:

Directory created successfully!

2. fs.mkdirSync()

The fs.mkdirSync() method is the synchronous version. This "blocks" the execution of your code; the script stops and waits until the folder is created before moving to the next line.

const fs = require('fs');

try {
  fs.mkdirSync('backups');
  console.log('Backup directory created');
} catch (err) {
  console.error('Error creating folder:', err);
}

Output:

Backup directory created

Reading Directories

1. fs.readdir()

The fs.readdir() method scans a directory and returns an array containing the names of all files and folders found inside it.

const fs = require('fs');

fs.readdir('./my_project', (err, files) => {
  if (err) throw err;
  console.log('Contents:', files);
});

Output:

Contents: [ 'index.js', 'package.json', 'node_modules', 'public' ]

2. fs.readdirSync()

This is useful when you need to get a list of files immediately before proceeding with your logic, such as loading all configuration files from a folder at startup.

const fs = require('fs');

const items = fs.readdirSync('.');
items.forEach(item => {
  console.log('Found item:', item);
});

Removing Directories

1. fs.rmdir()

The fs.rmdir() method is specifically designed to remove a directory. By default, in older versions of Node.js, this method only works if the directory is empty.

const fs = require('fs');

fs.rmdir('temp_logs', (err) => {
  if (err) throw err;
  console.log('Empty directory removed');
});

2. fs.rmdirSync()

The synchronous version of folder removal. Like its counterpart, it will throw an error if the directory does not exist or if it contains files (unless specific flags are used).

const fs = require('fs');

fs.rmdirSync('old_data');
console.log('Directory removed');

3. fs.rmdir() for Non-Empty Directories

In older Node.js scripts, you had to manually delete every file inside a folder before you could delete the folder itself. Here is a practical look at how that logic functions:

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

function cleanAndRemove(dirPath) {
  if (fs.existsSync(dirPath)) {
    // Read all files in the directory
    fs.readdir(dirPath, (err, files) => {
      if (err) throw err;

      files.forEach((file) => {
        const currentPath = path.join(dirPath, file);
        // Remove individual file
        fs.unlink(currentPath, (err) => {
          if (err) throw err;
        });
      });

      // Finally, remove the now-empty directory
      fs.rmdir(dirPath, (err) => {
        if (err) throw err;
        console.log('Folder cleared and deleted.');
      });
    });
  }
}

cleanAndRemove('temp_uploads');

Checking if a Directory Exists

1. fs.existsSync()

Before trying to create or read a folder, it’s often smart to check if it actually exists to avoid crashing your app with an error.

const fs = require('fs');

const dir = './data_store';

if (fs.existsSync(dir)) {
  console.log('Folder found! Proceeding with data load...');
} else {
  console.log('Folder not found. Creating it now...');
  fs.mkdirSync(dir);
}

Output:

Folder not found. Creating it now...

Summary

Mastering the fs module allows you to build Node.js applications that are organized and capable of handling complex file-based data. By using fs.mkdir() to create structures, fs.readdir() to inspect them, and fs.rm() to clean them up, you gain full control over the local environment. Always remember to use asynchronous methods for performance-critical applications and leverage the path module to keep your code compatible across different operating systems.