File System Operations

Node.js Fundamentals — File System Operations

Node.js Fundamentals

Course 1 · Chapter 5 · File System Operations

📁 File System Operations

Node.js provides the fs (File System) module to interact with files and directories. You can read, write, delete, and manipulate files. This chapter covers reading files, writing files, working with directories, using async/await with the promises API, and common patterns for file operations.

📖 The fs Module

The fs module is built into Node.js. Import it to access file operations:

const fs = require('fs');
const { promises: fsp } = require('fs');

// Or in modern Node.js:
import { promises as fs } from 'fs';
        

The fs module provides three ways to work with files:

Synchronous (Blocking)

readFileSync(), writeFileSync() — blocks execution. Avoid in production!

Callback (Old)

readFile(), writeFile() with callback — harder to use.

Promises (Modern)

fs.promises.readFile() — returns promise, works with async/await.

Streams

For large files — efficient memory usage (we'll cover later).

📚 Reading Files

Read Text File (Async/Await)

const { promises: fs } = require('fs');

async function readTextFile(filename) {
  try {
    const content = await fs.readFile(filename, 'utf8');
    console.log('File content:', content);
    return content;
  } catch (error) {
    console.error('Error reading file:', error.message);
  }
}

await readTextFile('data.txt');
        

Read as Buffer (Binary Data)

const data = await fs.readFile('image.png');
console.log('Buffer length:', data.length); // bytes
        

✍️ Writing Files

Write Text (Creates or Overwrites)

async function writeFile(filename, content) {
  try {
    await fs.writeFile(filename, content, 'utf8');
    console.log('✓ File written');
  } catch (error) {
    console.error('Error writing file:', error.message);
  }
}

await writeFile('output.txt', 'Hello, World!');
        

Append to File

async function appendFile(filename, content) {
  await fs.appendFile(filename, content, 'utf8');
  console.log('✓ Content appended');
}

await appendFile('log.txt', '\nNew log entry');
        

📂 Directory Operations

List Files in Directory

async function listFiles(dirname) {
  try {
    const files = await fs.readdir(dirname);
    console.log('Files:', files);
    return files;
  } catch (error) {
    console.error('Error reading directory:', error.message);
  }
}

await listFiles('./data');
        

Create Directory

async function createDir(dirname) {
  await fs.mkdir(dirname, { recursive: true });
  console.log('✓ Directory created');
}

await createDir('./output/subdir');
        

ℹ️ File Information

async function getFileStats(filename) {
  const stats = await fs.stat(filename);

  console.log('File size:', stats.size, 'bytes');
  console.log('Is file?', stats.isFile());
  console.log('Is directory?', stats.isDirectory());
  console.log('Modified:', stats.mtime);
}

await getFileStats('data.txt');
        

🗑️ Deleting Files & Directories

// Delete a file
await fs.unlink('old-file.txt');

// Delete a directory (must be empty)
await fs.rmdir('./empty-dir');

// Delete recursively (Node.js 14.14+)
await fs.rm('./dir-with-files', { recursive: true });
        

🔄 Common Patterns

Process JSON File

async function loadConfig(filename) {
  const json = await fs.readFile(filename, 'utf8');
  const config = JSON.parse(json);
  return config;
}

const config = await loadConfig('config.json');
        

Copy File

async function copyFile(src, dest) {
  const content = await fs.readFile(src);
  await fs.writeFile(dest, content);
  console.log('✓ File copied');
}

await copyFile('original.txt', 'backup.txt');
        

💻 Coding Challenges

Challenge 1: Read & Process Text File

Read a text file, count lines/words, and write statistics to a new file.

Goal: Practice reading files and basic text processing.

→ Solution

Challenge 2: JSON Config Management

Read a JSON config file, modify values, and write it back. Handle missing files gracefully.

Goal: Work with JSON files and error handling.

→ Solution

Challenge 3: Directory Operations

List all files in a directory, filter by extension, and generate a file report.

Goal: Master directory reading and file metadata.

→ Solution

💡 File I/O Best Practices

1. Always use async/await: Never use synchronous file operations in production code.

2. Handle errors: Files might not exist, disk might be full, permissions might be denied.

3. Use streams for large files: Reading a 10GB file into memory is a bad idea!

4. Consider paths carefully: Use path.join() for cross-platform compatibility.

🎯 What's Next

Now that you can read and write files, we'll explore HTTP Servers — using Node.js to create web servers and handle HTTP requests.