Cosa sono gli stream in Node.js e quando dovresti usarli?

Question

Accepted Answer

Gli **stream** elaborano i dati **incrementalmente, in blocchi**, anziché caricarli tutti in memoria in una volta. Questo li rende essenziali per dati di grandi dimensioni (file grandi, trasferimenti di rete) dove il buffering di tutto esaurirebbe la memoria.

## Il problema che gli stream risolvono

```js
// ❌ loads the ENTIRE file into memory — crashes on a 10GB file
const data = await fs.promises.readFile("huge.csv");
process(data);

// ✅ stream it — constant memory, processes chunk by chunk
fs.createReadStream("huge.csv")
  .pipe(transform)
  .pipe(fs.createWriteStream("out.csv"));
```

Con gli stream, l'utilizzo della memoria rimane piatto indipendentemente dalla dimensione del file — gestisci un blocco alla volta.

## I quattro tipi di stream

```text
Readable  → source you read FROM (fs.createReadStream, http request)
Writable  → destination you write TO (fs.createWriteStream, http response)
Duplex    → both readable & writable (TCP socket)
Transform → modify data as it passes through (zlib gzip, encryption)
```

## pipe — connetti gli stream

```js
import { createReadStream, createWriteStream } from "fs";
import { createGzip } from "zlib";

// read → compress → write, all streaming, low memory
createReadStream("file.txt")
  .pipe(createGzip())            // Transform: compress on the fly
  .pipe(createWriteStream("file.txt.gz"));
```

`pipe` collega un readable a un writable (con trasformazioni in mezzo), gestendo automaticamente il flusso — il modo idiomatico per comporre gli stream.

## pipeline — pipe con gestione degli errori appropriata

```js
import { pipeline } from "stream/promises";

await pipeline(
  createReadStream("in.txt"),
  createGzip(),
  createWriteStream("out.gz")
); // ✅ cleans up all streams on error/completion (pipe alone leaks on errors)
```

`pipeline` è preferibile ai `.pipe()` concatenati perché propaga gli errori e pulisce correttamente ogni stream.

## Perché è importante

Gli stream sono una caratteristica distintiva di Node per la gestione **efficiente della memoria** di dati grandi o continui — la differenza tra un'app che si arresta in crash su un grande caricamento e una che gestisce qualsiasi dimensione con memoria piatta.

Comprendere i quattro tipi, la composizione `pipe`/`pipeline` (e perché `pipeline` è più sicuro), e che le richieste/risposte HTTP sono essi stessi stream, è essenziale per creare servizi scalabili di gestione file, elaborazione dati e proxy in Node.

## Dove gli stream appaiono

```text
✓ HTTP request/response bodies (req and res ARE streams)
✓ File reading/writing, file uploads/downloads
✓ Compression (zlib), encryption (crypto)
✓ Database cursors, large query results
✓ Real-time data processing, video streaming
```

## Quando NON preoccuparsi

```text
Small data that fits comfortably in memory → readFile/simple buffering is simpler.
Streams add complexity; use them for LARGE or continuous data.
```