¿Qué son los streams en Node.js y cuándo deberías usarlos?

Question

Accepted Answer

Los **streams** procesan datos **de forma incremental, en chunks**, en lugar de cargarlos todos en memoria a la vez. Esto los hace esenciales para datos grandes (archivos grandes, transferencias de red) donde almacenarlo todo en buffer agotaría la memoria.

## El problema que resuelven los streams

```js
// ❌ carga el archivo COMPLETO en memoria — se cae con un archivo de 10GB
const data = await fs.promises.readFile("huge.csv");
process(data);

// ✅ procésalo como stream — memoria constante, chunk por chunk
fs.createReadStream("huge.csv")
  .pipe(transform)
  .pipe(fs.createWriteStream("out.csv"));
```

Con streams, el uso de memoria se mantiene plano sin importar el tamaño del archivo — manejas un chunk a la vez.

## Los cuatro tipos de stream

```text
Readable  → fuente DESDE la que lees (fs.createReadStream, http request)
Writable  → destino HACIA el que escribes (fs.createWriteStream, http response)
Duplex    → readable y writable a la vez (socket TCP)
Transform → modifica los datos al pasar a través (zlib gzip, encriptación)
```

## pipe — conectar streams

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

// leer → comprimir → escribir, todo en streaming, poca memoria
createReadStream("file.txt")
  .pipe(createGzip())            // Transform: comprime al vuelo
  .pipe(createWriteStream("file.txt.gz"));
```

`pipe` conecta un readable a un writable (con transforms en medio), gestionando automáticamente el flujo — la forma idiomática de componer streams.

## pipeline — pipe con manejo de errores adecuado

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

await pipeline(
  createReadStream("in.txt"),
  createGzip(),
  createWriteStream("out.gz")
); // ✅ limpia todos los streams en caso de error/finalización (pipe solo tiene fugas en errores)
```

`pipeline` se prefiere sobre el encadenamiento de `.pipe()` porque propaga los errores y limpia correctamente cada stream.

## Dónde aparecen los streams

```text
✓ Cuerpos de request/response HTTP (req y res SON streams)
✓ Lectura/escritura de archivos, subidas/descargas de archivos
✓ Compresión (zlib), encriptación (crypto)
✓ Cursores de bases de datos, resultados de consultas grandes
✓ Procesamiento de datos en tiempo real, streaming de video
```

## Cuándo NO molestarse

```text
Datos pequeños que caben cómodamente en memoria → readFile/buffering simple es más sencillo.
Los streams agregan complejidad; úsalos para datos GRANDES o continuos.
```

## Por qué es importante

Los streams son una característica distintiva de Node para el manejo **eficiente en memoria** de datos grandes o continuos — la diferencia entre una app que se cae con una subida grande y una que maneja cualquier tamaño con memoria plana.

Entender los cuatro tipos, la composición con `pipe`/`pipeline` (y por qué `pipeline` es más seguro), y que las requests/responses HTTP son en sí mismas streams, es esencial para construir servicios escalables de manejo de archivos, procesamiento de datos y proxying en Node.