X'inhuma streams fil-Node.js u meta għandek tuża tagħhom?

Question

Accepted Answer

**Streams** jipproċessjaaw data **gradwalment, fi qorti**, minflok li jiċċaraw kollha fil-memorja immed. Dan jagħmlihom essenzjali għal data kbira (fajls kbir, trasferimenti tal-network) fejn il-buffering ta' kollox ikun ieqaf il-memorja.

## Il-problema li streams isolvu

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

Ma' streams, l-użu tal-memorja jibqa' ċatt ma' jmiss id-daqs tal-fajl — inti tħandel qorti waħda b'kull darba.

## Ix-xejra l-erbgħa ta' 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 — konnetti 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` jikkonekta readable ma' writable (b'transforms bejniethom), u jiggerenji l-fluss awtomatikament — id-daħla idiomatic biex tikkomponi streams.

## pipeline — pipe b'error handling korrett

```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` huwa preferit fuq `.pipe()` miċħuċ għax jipropaga l-errors u jnaqqas b'mod corrett kull stream.

## Fejn jidhru streams

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

## Meta ma tħaggħox

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

## Għaliex dan importanti

Streams huma feature li tiddefinixxi Node għal **memory-efficient** handling ta' data kbira jew kontinwa — id-differenza bejn app li titkisser fuq upload kbir u waħda li tħandel kwalunkwe daqs b'memorja ċatta.

Fhem it-xejra l-erbgħa, `pipe`/`pipeline` composition (u għaliex `pipeline` huwa safer), u li HTTP requests/responses huma stess streams huwa essenzjali biex tibni servizzi skalabbli għal handling tal-fajls, data-processing, u proxying fil-Node.