Wie arbeitet man mit dem Dateisystem in Node?

Question

IT Interview Practice · Accepted Answer

Das eingebaute **`fs`** Modul liest und schreibt Dateien und Verzeichnisse. Es bietet drei API-Stile — **promises** (modern, empfohlen), **callbacks** (original asynchron) und **sync** (blockierend) — damit du die richtige für die Situation wählen kannst.

## Die promise API (empfohlen)

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

Die `fs/promises` API funktioniert sauber mit async/await — der moderne Standard für Datei-I/O.

## Callback- und sync-Varianten

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

**Vorsicht:** `*Sync` Methoden **blockieren die gesamte Event Loop**, bis die Operation abgeschlossen ist. Sie sind beim Start in Ordnung (Konfiguration einmal laden), sollten aber in Request-Handlern vermieden werden — ein blockierendes Lesen gefriert alle gleichzeitigen Anfragen ein.

## Häufige Operationen

```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 große Dateien: Streams verwenden

```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"));
```

Bei großen Dateien lädt `readFile` alles auf einmal in den Speicher; **Streams** verarbeiten Daten in Chunks mit konstantem Speicher.

## Warum es wichtig ist

Datei-I/O ist eine Kernfähigkeit von Node zum Laden von Konfigurationen, Logging, Datei-Uploads/-Downloads und Tooling.

Die drei API-Stile zu kennen — und entscheidend, dass **sync Methoden die Event Loop blockieren** (vermeiden sie auf Servern) und dass **große Dateien Streams brauchen** (nicht `readFile`) — ist unerlässlich, um Code zur Dateiverarbeitung zu schreiben, der sowohl korrekt als auch leistungsfähig unter Concurrency ist.

Die promise API mit async/await ist der saubere Standard für die tägliche Verwendung.

Die promise API (empfohlen)

Callback- und sync-Varianten

Häufige Operationen

Für große Dateien: Streams verwenden

Warum es wichtig ist

Ähnliche Fragen