Node.js File System Operations

Learn to read, write, and manipulate files in Node.js. Understand sync vs async methods and best practices for file handling.

The fs module provides an API for interacting with the file system. It supports both synchronous and asynchronous operations.

Sync vs Async

Synchronous methods block the event loop until complete. Use them only during startup or in scripts. Always prefer async methods in servers.

Reading Files

Use fs.readFile for small files, fs.createReadStream for large files. Choose the right encoding (utf8 for text, null for binary).

Writing Files

Use fs.writeFile for complete overwrites, fs.appendFile for adding to files. For large data, use streams.

Working with Directories

Create directories with fs.mkdir, list contents with fs.readdir, and recursively work with directories using the recursive option.

File Watching

Monitor files and directories for changes using fs.watch or fs.watchFile. Useful for development tools and live reload.

Code Examples

Reading and Writing Files

file-operations.js
const fs = require('fs').promises;
const path = require('path');

async function fileOperations() {
  const filePath = path.join(__dirname, 'data.txt');

  // Write file
  await fs.writeFile(filePath, 'Hello, Node.js!', 'utf8');
  console.log('File written');

  // Read file
  const content = await fs.readFile(filePath, 'utf8');
  console.log('Content:', content);

  // Append to file
  await fs.appendFile(filePath, '\nAppended text');
  console.log('Content appended');

  // Get file stats
  const stats = await fs.stat(filePath);
  console.log('Size:', stats.size, 'bytes');
  console.log('Modified:', stats.mtime);

  // Delete file
  await fs.unlink(filePath);
  console.log('File deleted');
}

fileOperations().catch(console.error);

Working with Directories

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

async function listFilesRecursively(dir) {
  const entries = await fs.readdir(dir, { withFileTypes: true });
  const files = [];

  for (const entry of entries) {
    const fullPath = path.join(dir, entry.name);
    if (entry.isDirectory()) {
      files.push(...await listFilesRecursively(fullPath));
    } else {
      files.push(fullPath);
    }
  }

  return files;
}

async function main() {
  // Create directory
  await fs.mkdir('my-folder/nested', { recursive: true });

  // List all files
  const files = await listFilesRecursively('./src');
  console.log('All files:', files);

  // Copy directory contents
  await fs.cp('source', 'destination', { recursive: true });
}

main().catch(console.error);

File Streaming

streaming.js
const fs = require('fs');
const { pipeline } = require('stream/promises');
const zlib = require('zlib');

// Stream large file with compression
async function compressFile(input, output) {
  await pipeline(
    fs.createReadStream(input),
    zlib.createGzip(),
    fs.createWriteStream(output)
  );
  console.log('File compressed');
}

// Copy large file efficiently
async function copyLargeFile(src, dest) {
  const readStream = fs.createReadStream(src);
  const writeStream = fs.createWriteStream(dest);

  await pipeline(readStream, writeStream);
  console.log('File copied');
}

compressFile('large-file.txt', 'large-file.txt.gz')
  .catch(console.error);

Frequently Asked Questions

When should I use streams vs readFile?

Use streams for files larger than a few MB, when you need to process data as it arrives, or when memory is constrained. readFile loads the entire file into memory at once.

How do I ensure files are written before reading?

Always await file write operations before reading. For extra safety in critical applications, use fsync via fs.fdatasync() or open files with the 'sync' flag.

What's the best way to handle file paths across platforms?

Always use path.join() or path.resolve() instead of string concatenation. This handles different path separators on Windows vs Unix automatically.

Related Topics

Node.js StreamsAsync Programming in Node.jsNode.js Performance Optimization

Need Node.js Help?

Slashdev.io builds production-ready Node.js applications for businesses of all sizes.

Get in Touch

Resources

Official DocumentationGitHub Repositorynpm Registry