Come si lavora con il file system in Node?

Question

Accepted Answer

Il modulo integrato **`fs`** legge e scrive file e directory. Offre tre stili di API — **promises** (moderno, consigliato), **callbacks** (async originale), e **sync** (bloccante) — così potete scegliere quello giusto per la situazione.

## L'API promise (consigliato)

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

L'API `fs/promises` funziona perfettamente con async/await — lo standard moderno per l'I/O dei file.

## Varianti callback e sync

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

**Attenzione:** i metodi `*Sync` **bloccano l'intero event loop** finché l'operazione non finisce. Vanno bene all'avvio (caricamento della configurazione una volta) ma dovrebbero essere evitati nei gestori di richieste — una lettura bloccante congela tutte le richieste concorrenti.

## Operazioni comuni

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

## Per file grandi: usare gli stream

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

Per i file grandi, `readFile` carica tutto in memoria in una volta; gli **stream** elaborano i dati in blocchi con memoria costante.

## Perché è importante

L'I/O del file è una capacità fondamentale di Node per il caricamento delle configurazioni, la registrazione, il caricamento/download di file e il tooling.

Conoscere i tre stili di API — e fondamentalmente, che **i metodi sync bloccano l'event loop** (evitarli nei server) e che **i file grandi hanno bisogno di stream** (non `readFile`) — è essenziale per scrivere codice di gestione dei file che sia sia corretto che performante in caso di concorrenza.

L'API promise con async/await è lo standard pulito per l'uso quotidiano.