Hur arbetar du med filsystemet i Node?

Question

IT Interview Practice · Accepted Answer

Den inbyggda **`fs`**-modulen läser och skriver filer och kataloger. Den erbjuder tre API-stilar — **promises** (modern, föredraget), **callbacks** (ursprunglig async) och **sync** (blockering) — så du kan välja rätt för situationen.

## Promise-API:et (rekommenderat)

```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
}
```

`fs/promises`-API:et fungerar snyggt med async/await — den moderna standarden för fil-I/O.

## Callback- och sync-varianter

```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!
```

**Varning:** `*Sync`-metoder **blockerar hela event loop** tills operationen är klar. De är okej vid start (läsa config en gång) men bör undvikas i request-hanterare — en blockering läsning fryser alla samtidiga begäranden.

## Vanliga operationer

```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
```

## För stora filer: använd 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"));
```

För stora filer läser `readFile` allt i minnet på en gång; **streams** bearbetar data i bitar med konstant minne.

## Varför det spelar roll

Fil-I/O är en kärnfunktion i Node för config-inladdning, loggning, filuppladdningar/nedladdningar och verktyg.

Att känna till de tre API-stilarna — och avgörande, att **sync-metoder blockerar event loop** (undvik dem i servrar) och att **stora filer behöver streams** (inte `readFile`) — är väsentligt för att skriva fil-hanteringskod som är både korrekt och performant under concurrency.

Promise-API:et med async/await är den snygga standarden för vardaglig användning.

Promise-API:et (rekommenderat)

Callback- och sync-varianter

Vanliga operationer

För stora filer: använd streams

Varför det spelar roll

Relaterade frågor