Reading and Writing Files in Node.js with the File System (fs) Module

The File System (fs) module in Node.js provides methods for interacting with the file system, enabling applications to read, write, update, and delete files. Understanding how to work with files is crucial for building applications that manage user data, logs, and configurations.

This guide will cover reading and writing files using both synchronous and asynchronous approaches in Node.js.

1. Importing the File System (fs) Module

To use file operations in Node.js, you need to import the built-in fs module.

const fs = require('fs');

This module provides both synchronous and asynchronous methods for file handling.

2. Writing Files in Node.js

2.1 Writing Files Asynchronously (Recommended)

The asynchronous method fs.writeFile() writes data to a file without blocking execution.

const fs = require('fs');

fs.writeFile('example.txt', 'Hello, this is a sample text!', (err) => {
    if (err) {
        console.error('Error writing file:', err);
        return;
    }
    console.log('File written successfully');
});

• If the file does not exist, it is created.

• If the file exists, its contents are replaced.

• A callback function is used to handle errors.

2.2 Writing Files Synchronously

The synchronous method fs.writeFileSync() blocks execution until the file is written.

const fs = require('fs');

try {
    fs.writeFileSync('example.txt', 'Hello, this is a sample text!');
    console.log('File written successfully');
} catch (err) {
    console.error('Error writing file:', err);
}

• This approach should be used when immediate execution of the next operation depends on file writing.

2.3 Appending Data to a File

Use fs.appendFile() to add content to an existing file instead of overwriting it.

fs.appendFile('example.txt', '\nAdditional text appended.', (err) => {
    if (err) {
        console.error('Error appending file:', err);
        return;
    }
    console.log('Content appended successfully');
});

This is useful for logging and continuous data updates.

3. Reading Files in Node.js

3.1 Reading Files Asynchronously (Recommended)

The fs.readFile() method reads file contents asynchronously.

fs.readFile('example.txt', 'utf8', (err, data) => {
    if (err) {
        console.error('Error reading file:', err);
        return;
    }
    console.log('File content:', data);
});

• The 'utf8' encoding ensures the content is read as text instead of a buffer.

• The callback function handles errors and logs the file content.

3.2 Reading Files Synchronously

The fs.readFileSync() method reads the file synchronously, blocking execution.

try {
    const data = fs.readFileSync('example.txt', 'utf8');
    console.log('File content:', data);
} catch (err) {
    console.error('Error reading file:', err);
}

• Use this when you need to ensure the file is fully read before proceeding.

3.3 Checking if a File Exists

Before reading a file, it’s good practice to check if it exists using fs.existsSync().

if (fs.existsSync('example.txt')) {
    console.log('File exists');
} else {
    console.log('File does not exist');
}

This prevents errors when trying to read a non-existent file.

4. Deleting Files in Node.js

4.1 Deleting Files Asynchronously

Use fs.unlink() to delete a file asynchronously.

fs.unlink('example.txt', (err) => {
    if (err) {
        console.error('Error deleting file:', err);
        return;
    }
    console.log('File deleted successfully');
});

4.2 Deleting Files Synchronously

Use fs.unlinkSync() to delete a file synchronously.

try {
    fs.unlinkSync('example.txt');
    console.log('File deleted successfully');
} catch (err) {
    console.error('Error deleting file:', err);
}

• The synchronous approach blocks execution until the file is deleted.

5. Watching File Changes in Node.js

Node.js provides the fs.watch() method to monitor file changes.

fs.watch('example.txt', (eventType, filename) => {
    console.log(`File ${filename} was modified: ${eventType}`);
});

• This is useful for logging changes, live file updates, or real-time monitoring.

6. Best Practices for File Handling in Node.js

1. Use asynchronous methods (fs.writeFile(), fs.readFile()) to prevent blocking operations.

2. Handle errors properly using callback functions, try...catch, or promises.

3. Use utf8 encoding to work with text files instead of raw buffers.

4. Check file existence before performing operations using fs.existsSync().

5. Use streams (fs.createReadStream(), fs.createWriteStream()) for handling large files efficiently.

7. Conclusion

In this guide, we explored how to:

• Write and append files using fs.writeFile() and fs.appendFile().

• Read files asynchronously and synchronously with fs.readFile().

• Delete files with fs.unlink().

• Monitor file changes with fs.watch().