Node.js File Handling

File handling is a foundational skill in backend development, enabling applications to read, write, and manipulate data stored on disk. In Node.js, this capability is powered by the built-in (File System) module, which offers both synchronous and asynchronous methods to interact with files and directories. Whether you’re building a logging system, managing user uploads, or parsing configuration files, mastering file operations is essential for creating robust and scalable applications.
At its core, Node.js promotes non-blocking I/O, making asynchronous file handling the preferred approach for performance-sensitive environments. The module supports callbacks, promises, and stream-based operations, each suited to different use cases. For example, reading a small config file might use , while processing a large CSV would benefit from to avoid memory bottlenecks.
Beyond basic read/write tasks, Node.js allows developers to append data, rename files, monitor changes, and traverse directories. These operations become especially powerful when combined with real-world scenarios like log rotation, dynamic content generation, or automated backups. Additionally, understanding how to handle errors gracefully, such as missing files or permission issues, is crucial for building resilient systems.
This module will walk you through practical examples of file handling, from simple text manipulation to advanced stream processing. Each concept is broken down with clear syntax, use-case-driven explanations, and performance considerations. By the end, you’ll be equipped to integrate file operations seamlessly into your Node.js applications, whether you’re building APIs, CLI tools, or server-side utilities.

Node.js File Handling Features

1. Asynchronous & Synchronous APIs– Offers both non-blocking () and blocking () methods for flexibility in performance-critical or simple tasks.
2. Promise-based Interface ()– Modern, cleaner syntax using , ideal for structured error handling and readable code.
3. Stream Support for Large Files– Use and to process massive files without loading them entirely into memory.
4. Directory Manipulation– Create, read, rename, and delete directories using methods like , , and .
5. File Watching ()– Monitor changes to files or directories in real time—useful for live reloads, logging, or triggering automated tasks.
6. Buffer Integration– Read and write binary data efficiently using buffers, especially useful for image, audio, or video processing.
7. Error Handling & Permissions– Robust error reporting for missing files, permission issues, and invalid paths—critical for building resilient systems.
8. Cross-platform Path Handling ( module)– Seamlessly manage file paths across Windows, Linux, and macOS using , , etc.

Example Codes-

Importing the Module

// CommonJS
const fs = require(‘fs’);

// Promise-based API (modern)
const fsPromises = require(‘fs’).promises;

Reading Files

fs.readFile(‘example.txt’, ‘utf8’, (err, data) => {
if (err) throw err;
console.log(data);
});

Promise-based (Preferred for async/await)

async function readFile() {
const data = await fsPromises.readFile(‘example.txt’, ‘utf8’);
console.log(data);
}
readFile();

Synchronous (Blocking)

const data = fs.readFileSync(‘example.txt’, ‘utf8’);
console.log(data);

Writing Files

fs.writeFile(‘output.txt’, ‘Hello, Node.js!’, err => {
if (err) throw err;
console.log(‘File written successfully’);
});

Promise-based

await fsPromises.writeFile(‘output.txt’, ‘Hello, Node.js!’);

Synchronous

fs.writeFileSync(‘output.txt’, ‘Hello, Node.js!’);