How to Remove directory which is not empty using nodejs

In Node.js, deleting a non-empty directory requires recursively removing all files and subdirectories within it. Starting from Node.js version 12.10.0, the fs module provides the { recursive: true } option for the rmdir method, significantly simplifying this process. Here is a step-by-step guide demonstrating how to delete a non-empty directory using Node.js:

1. Using the fs.rmdir Method

For Node.js versions 12.10.0 and above, you can directly use the fs.rmdir method with the recursive option set to true to delete non-empty directories. This is the most straightforward approach:

javascript
const fs = require('fs');

const directoryPath = 'path/to/directory';

fs.rmdir(directoryPath, { recursive: true }, (err) => {
  if (err) {
    console.error(`Error: ${err.message}`);
  } else {
    console.log('Directory removed successfully!');
  }
});

2. Using the fs.promises API

If you prefer working with Promises, you can implement it as follows:

javascript
const fs = require('fs').promises;

const directoryPath = 'path/to/directory';

fs.rmdir(directoryPath, { recursive: true })
  .then(() => {
    console.log('Directory removed successfully!');
  })
  .catch((err) => {
    console.error(`Error: ${err.message}`);
  });

3. Manual Recursive Deletion

If you're using an earlier Node.js version or need to manually handle recursive deletion, follow this implementation:

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

const directoryPath = 'path/to/directory';

function deleteDirectory(directoryPath) {
  fs.readdir(directoryPath, (err, files) => {
    if (err) {
      return console.error(`Error: ${err.message}`);
    }

    files.forEach((file) => {
      const curPath = path.join(directoryPath, file);
      fs.stat(curPath, (err, stats) => {
        if (err) {
          return console.error(`Error: ${err.message}`);
        }

        if (stats.isDirectory()) {
          // Recursively delete subdirectories
          deleteDirectory(curPath);
        } else {
          // Delete files directly
          fs.unlink(curPath, (err) => {
            if (err) {
              console.error(`Error: ${err.message}`);
            }
          });
        }
      });
    });

    // Delete the now-empty parent directory
    fs.rmdir(directoryPath, (err) => {
      if (err) {
        console.error(`Error: ${err.message}`);
      } else {
        console.log('Directory removed successfully!');
      }
    });
  });
}

deleteDirectory(directoryPath);

In this code, we first read all files and subdirectories within the directory, then evaluate each item: files are deleted directly, while subdirectories trigger recursive deletion. Finally, the parent directory is removed once it becomes empty.

These methods effectively enable deletion of non-empty directories in Node.js. For production environments, it's recommended to use built-in approaches like { recursive: true } for fs.rmdir, as they are more concise and have undergone extensive testing.