Cad iad streams i Node.js agus cathain ba chóir duit iad a úsáid?

Question

Accepted Answer

**Streams** a phróiseálaíonn sonraí **de réir a chéile, i ndánta**, in ionad gach rud a lódáil isteach sa chuimhne ag an am céanna. Fágann sé seo go bhfuil siad riachtanach do shonraí mhóra (comhaid mhóra, aistriúcháin an gréasáin) nuair a dhéanfadh stóráil iomlán sa bhunachar scríobh an chuimhne a dhíothú.

## An fhadhb a réitíonn streams

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

Le streams, fanann úsáid an chuimhne foluain beag is beachta de bharr fhad an chomhaid — déileálann tú le dánta amháin ag an am.

## Na ceithre chineál sreabhach

```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 — sreabhanna a nascadh

```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` ceangailte a léite le scríobhtha (agus claochlaithe eatarthu), bainistiú an sreabha go huathoibríoch — an bealach idiomatic a dhréachtú sreabhanna.

## pipeline — píobán agus láimhseáil earráide ar bhealach cuí

```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` is fearr a leagan os cionn gréine `.pipe()` toisc go scaipeann sé earráidí agus glanann sé gach sreabh i gceart.

## Áit ar fhéachann sreabhanna

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

## Cathain nach ba chóir a dhul sa bhuairt

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

## Cén fáth a bhíonn tábhacht aici

Is gné shainiúil atá i streams Node a dhéileáil go **éifeachtach ar an gcuimhne** le sonraí móra nó leanúnach — an difríochtí idir aip a bhriseann ar uachtar mór agus ceann a dhéileálann le haon méid le cuimhne foluain.

Tuiscint ar na ceithre chineál, comhdhéanamh `pipe`/`pipeline` (agus cén fáth gur slándáil `pipeline`), agus go bhfuil iarratas/fregra HTTP ina sreabhanna féin, is gá chun seirbhísí inéadaithe líon-láimhseáil, próiseáil sonraí, agus seachfhreastalaithe a thógáil i Node.