Que sont les streams dans Node.js et quand devriez-vous les utiliser ?

Question

Accepted Answer

**Streams** traitent les données **progressivement, par chunks**, plutôt que de les charger entièrement en mémoire à la fois. Cela les rend essentiels pour les grandes quantités de données (gros fichiers, transferts réseau) où mettre en buffer tout serait catastrophique pour la mémoire.

## Le problème que les streams résolvent

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

Avec les streams, l'utilisation mémoire reste plate quel que soit la taille du fichier — vous traitez un chunk à la fois.

## Les quatre types de streams

```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 — connecter des streams

```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` relie un readable à un writable (avec des transforms entre les deux), en gérant automatiquement le flux — la façon idiomatique de composer des streams.

## pipeline — pipe avec gestion d'erreurs appropriée

```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` est préféré aux chaînes `.pipe()` car il propage les erreurs et nettoie correctement chaque stream.

## Où les streams apparaissent

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

## Quand NE PAS vous embêter

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

## Pourquoi c'est important

Les streams sont une fonctionnalité déterminante de Node pour la gestion **économe en mémoire** de grandes quantités de données ou de données continues — la différence entre une application qui plante sur un gros upload et une qui gère n'importe quelle taille avec une mémoire stable.

Comprendre les quatre types, la composition `pipe`/`pipeline` (et pourquoi `pipeline` est plus sûr), et que les requêtes/réponses HTTP sont elles-mêmes des streams est essentiel pour construire des services de gestion de fichiers, de traitement de données et de proxying scalables dans Node.