Node.js File System: Working with Files and Directories

File System Module

The Node.js fs module provides an API for interacting with the file system. It offers both synchronous and asynchronous methods for file operations.

Reading Files

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

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

// Using promises
const fsPromises = require("fs").promises;

async function readFileAsync() {
    try {
        const data = await fsPromises.readFile("example.txt", "utf8");
        console.log("File content:", data);
    } catch (err) {
        console.error("Error:", err);
    }
}

readFileAsync();

Writing Files

const fs = require("fs");

// Write to file (overwrites existing content)
const content = "Hello, Node.js!
This is a new file.";

fs.writeFile("output.txt", content, "utf8", (err) => {
    if (err) {
        console.error("Error writing file:", err);
        return;
    }
    console.log("File written successfully!");
});

// Append to file
fs.appendFile("output.txt", "
Appended content", (err) => {
    if (err) {
        console.error("Error appending to file:", err);
        return;
    }
    console.log("Content appended!");
});

Working with Directories

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

// Create directory
fs.mkdir("new-directory", { recursive: true }, (err) => {
    if (err) {
        console.error("Error creating directory:", err);
        return;
    }
    console.log("Directory created!");
});

// Read directory contents
fs.readdir(".", (err, files) => {
    if (err) {
        console.error("Error reading directory:", err);
        return;
    }
    console.log("Directory contents:", files);
});

// Get file/directory information
fs.stat("example.txt", (err, stats) => {
    if (err) {
        console.error("Error getting file stats:", err);
        return;
    }
    
    console.log("File size:", stats.size, "bytes");
    console.log("Is file:", stats.isFile());
    console.log("Is directory:", stats.isDirectory());
    console.log("Created:", stats.birthtime);
    console.log("Modified:", stats.mtime);
});

File Operations Utility

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

class FileManager {
    static async createFile(filePath, content) {
        try {
            await fs.writeFile(filePath, content, "utf8");
            console.log(`File created: ${filePath}`);
        } catch (err) {
            console.error("Error creating file:", err);
        }
    }
    
    static async copyFile(source, destination) {
        try {
            await fs.copyFile(source, destination);
            console.log(`File copied from ${source} to ${destination}`);
        } catch (err) {
            console.error("Error copying file:", err);
        }
    }
    
    static async deleteFile(filePath) {
        try {
            await fs.unlink(filePath);
            console.log(`File deleted: ${filePath}`);
        } catch (err) {
            console.error("Error deleting file:", err);
        }
    }
    
    static async listFiles(directory) {
        try {
            const files = await fs.readdir(directory);
            const fileDetails = [];
            
            for (const file of files) {
                const filePath = path.join(directory, file);
                const stats = await fs.stat(filePath);
                
                fileDetails.push({
                    name: file,
                    size: stats.size,
                    isDirectory: stats.isDirectory(),
                    modified: stats.mtime
                });
            }
            
            return fileDetails;
        } catch (err) {
            console.error("Error listing files:", err);
            return [];
        }
    }
}

// Usage example
async function demonstrateFileOperations() {
    // Create a file
    await FileManager.createFile("demo.txt", "This is a demo file.");
    
    // Copy the file
    await FileManager.copyFile("demo.txt", "demo-copy.txt");
    
    // List files in current directory
    const files = await FileManager.listFiles(".");
    console.log("Files in current directory:");
    files.forEach(file => {
        console.log(`${file.name} - ${file.size} bytes - ${file.modified}`);
    });
    
    // Clean up
    await FileManager.deleteFile("demo.txt");
    await FileManager.deleteFile("demo-copy.txt");
}

demonstrateFileOperations();

Streaming Large Files

const fs = require("fs");

// Reading large files with streams
function readLargeFile(filePath) {
    const readStream = fs.createReadStream(filePath, { encoding: "utf8" });
    
    readStream.on("data", (chunk) => {
        console.log("Received chunk of size:", chunk.length);
        // Process chunk
    });
    
    readStream.on("end", () => {
        console.log("File reading completed");
    });
    
    readStream.on("error", (err) => {
        console.error("Error reading file:", err);
    });
}

// Writing large files with streams
function writeLargeFile(filePath, data) {
    const writeStream = fs.createWriteStream(filePath);
    
    writeStream.write(data);
    writeStream.end();
    
    writeStream.on("finish", () => {
        console.log("File writing completed");
    });
    
    writeStream.on("error", (err) => {
        console.error("Error writing file:", err);
    });
}

Exercise

Create a file organizer that:

1. Scans a directory for files
2. Organizes files by extension into subdirectories
3. Creates a log file with operation details
4. Handles errors gracefully

What's Next?

In the next lesson, we'll learn to create HTTP servers and handle web requests using Node.js.