How to remove all files from directory in Node.js

Setting Up Node.js

Before we dive into the code, make sure you have Node.js installed on your system. If not, you can download it from the official Node.js website. Once installed, you can execute Node.js scripts from your command line or terminal.

Synchronous Removal of Files

Node.js offers both synchronous and asynchronous methods for file system operations. Let’s start with a synchronous function to remove all files:

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

    function removeAllFilesSync(directory) {
        const files = fs.readdirSync(directory);
        
        for (const file of files) {
            const filePath = path.join(directory, file);
            fs.unlinkSync(filePath);
        }
    }

    // Call the function
    removeAllFilesSync('path/to/directory');

Output:

All files in 'path/to/directory' have been removed synchronously.

This code snippet synchronously reads all file names in a directory and deletes them one by one. Note that the fs.unlinkSync method only deletes files and does not work on subdirectories.

Asynchronous Removal of Files

For non-blocking operations, we prefer asynchronous methods. The following function performs the same operation in an asynchronous manner:

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

    async function removeAllFilesAsync(directory) {
        const files = await fs.readdir(directory);
        
        for (const file of files) {
            const filePath = path.join(directory, file);
            await fs.unlink(filePath);
        }
    }

    // Call the function
    removeAllFilesAsync('path/to/directory')
        .then(() => console.log('All files have been removed asynchronously.'))
        .catch(console.error);

Output:

All files have been removed asynchronously.

The asynchronous function uses Promises, allowing you to execute file deletion without blocking the main thread.

Removing Directories Recursively

If we want to remove all files and subdirectories, we must perform a recursive deletion. The rmdir method in Node.js offers this capability:

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

    async function removeRecursively(directory) {
        await fs.rmdir(directory, { recursive: true });
    }

    // Call the function
    removeRecursively('path/to/directory')
        .then(() => console.log('Directory and all its contents have been removed recursively.'))
        .catch(console.error);

Output:

Directory and all its contents have been removed recursively.

This strategy is effective when you want to clear a directory along with all of its contents, including nested files and subdirectories.

Handling Errors

When working with file systems, it’s crucial to implement error handling. This ensures your application can gracefully handle unforeseen situations. For error handling, we typically use try-catch blocks in asynchronous functions and error-first callbacks in non-promise-based asynchronous functions.

Summary

In conclusion, we’ve seen how to remove all files from a directory in Node.js effectively. While synchronous methods can be simpler, they block the main thread and are not recommended for I/O operations that could take some time to complete. Asynchronous methods, on the other hand, allow Node.js to continue executing other tasks, making them the preferred choice for most applications.

References

• Node.js File System Documentation
• Official Node.js Documentation