How do you work with the file system in Node?

Question

Accepted Answer

The built-in **`fs`** module reads and writes files and directories. It offers three API styles — **promises** (modern, preferred), **callbacks** (original async), and **sync** (blocking) — so you can pick the right one for the situation.

## The promise API (recommended)

```js
import { readFile, writeFile, mkdir, readdir } from "fs/promises";

async function work() {
  const data = await readFile("input.txt", "utf8");     // read (utf8 → string)
  await writeFile("output.txt", "Hello");                // write (overwrites)
  await mkdir("new-dir", { recursive: true });           // create dirs (recursive = mkdir -p)
  const files = await readdir("./");                      // list directory contents
}
```

The `fs/promises` API works cleanly with async/await — the modern default for file I/O.

## Callback and sync variants

```js
import fs from "fs";

fs.readFile("file.txt", "utf8", (err, data) => { ... }); // async callback
const data = fs.readFileSync("file.txt", "utf8");         // SYNC — blocks the event loop!
```

**Caution:** `*Sync` methods **block the entire event loop** until the operation finishes. They're fine at startup (loading config once) but should be avoided in request handlers — a blocking read freezes all concurrent requests.

## Common operations

```js
await fs.promises.appendFile("log.txt", "new line
"); // append
await fs.promises.unlink("old.txt");                    // delete a file
await fs.promises.rename("a.txt", "b.txt");             // rename/move
const stats = await fs.promises.stat("file.txt");       // metadata (size, mtime)
const exists = fs.existsSync("file.txt");               // check existence
```

## For large files: use streams

```js
// ❌ readFile loads the WHOLE file into memory — bad for huge files
const huge = await readFile("10gb.txt"); // could exhaust memory

// ✅ stream it in chunks (constant memory)
fs.createReadStream("10gb.txt").pipe(fs.createWriteStream("copy.txt"));
```

For big files, `readFile` loads everything into memory at once; **streams** process data in chunks with constant memory.

## Why it matters

File I/O is a core Node capability for config loading, logging, file uploads/downloads, and tooling.

Knowing the three API styles — and crucially, that **sync methods block the event loop** (avoid them in servers) and that **large files need streams** (not `readFile`) — is essential for writing file-handling code that's both correct and performant under concurrency.

The promise API with async/await is the clean default for everyday use.