Mik a stream-ek a Node.js-ben, és mikor kell őket használni?

Question

IT Interview Practice · Accepted Answer

A **stream-ek** az adatokat **inkrementálisan, darabokra osztva** dolgozzák fel, ahelyett, hogy az egészet egyszerre töltenék be a memóriába. Ez azok számára nélkülözhetetlen nagy adatok (nagy fájlok, hálózati átvitelek) esetén, ahol a pufferelés a memória kimerüléséhez vezetne.

## A probléma, amelyet a stream-ek megoldanak

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

A stream-ek esetén a memória felhasználása a fájl méretétől függetlenül állandó marad — egyszerre csak egy darabbal foglalkozol.

## A négy stream típus

```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 — csatornázd össze a stream-eket

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

A `pipe` egy olvashatót egy írhatóhoz köt (közöttük átalakítások), és automatikusan kezeli az áramlást — az idiomatikus módja a stream-ek összetételének.

## pipeline — pipe a megfelelő hibakezeléssel

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

A `pipeline` előnyösebb a láncolódó `.pipe()` helyett, mert terjeszt hibákat és megfelelően megtisztítja az összes stream-et.

## Ahol a stream-ek megjelennek

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

## Amikor nem kell aggódni

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

## Miért fontos

A stream-ek a Node **memóriahatékony** kezelésének definiáló jellemzője a nagy vagy folyamatos adatok esetén — a különbség egy olyan alkalmazás között, amely nagy feltöltésen összeomlik, és egy, amely bármilyen méretű adatot egyenletes memória felhasználásával kezel.

A négy típus, a `pipe`/`pipeline` összetétel megértése (és miért `pipeline` biztonságosabb), valamint az, hogy a HTTP kérések/válaszok maguk is stream-ek, elengedhetetlen a Node-ban skálázható fájlkezelési, adatfeldolgozási és proxyképző szolgáltatások felépítéséhez.

A probléma, amelyet a stream-ek megoldanak

A négy stream típus

pipe — csatornázd össze a stream-eket

pipeline — pipe a megfelelő hibakezeléssel

Ahol a stream-ek megjelennek

Amikor nem kell aggódni

Miért fontos

Kapcsolódó kérdések