Node.js-లో streams అంటే ఏమిటి మరియు వాటిని ఎప్పుడు ఉపయోగించాలి?

Question

Accepted Answer

**Streams** డేటాను **క్రమంగా, చంకుల్లో** ప్రక్రియ చేస్తుంది, దానిని ఒకేసారి మెమరీకి లోడ్ చేయడానికి బదులుగా. ఇది పెద్ద డేటా (పెద్ద ఫైల్‌లు, నెట్‌వర్క్ బదిలీలు) కోసం అవసరమైనది, ఎక్కడ ప్రతిదీ బఫర్ చేయడం మెమరీని క్షయం చేస్తుంది.

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

Streams-ని ఉపయోగించి, ఫైల్ సైజు నిర్విశేషంగా మెమరీ వినియోగం చదునుగా ఉంటుంది — మీరు ఒక్కసారి ఒక చంకను నిర్వహిస్తారు.

## నాలుగు stream రకాలు

```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 — 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` ఒక readable-ను writable-కు కనెక్ట్ చేస్తుంది (మధ్యలో transforms-ని), ఆటోమేటిక్‌గా ఫ్లో-ను నిర్వహిస్తుంది — streams-ను కంపోజ్ చేసే సంప్రదాయ మార్గం.

## pipeline — సరైన error handling-ని ఉపయోగించిన pipe

```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` చేయిన చేయిన `.pipe()` కంటే ఆమోదయోగ్యమైనది ఎందుకంటే ఇది errors-ను ప్రసారం చేస్తుంది మరియు ప్రతిটి stream-ను సరిగ్గా శుభ్రం చేస్తుంది.

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

## ఎప్పుడు చింతించకూడదు

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

## ఎందుకు ముఖ్యమైనది

Streams పెద్ద లేదా నిరంతర డేటా యొక్క **మెమరీ-సమర్థమైన** సంచయన కోసం Node యొక్క నిర్వచించిన లక్షణం — పెద్ద అప్‌లోడ్‌లో క్రాష్ అయ్యే యాప్ మరియు ఏ పరిమాణాన్ని చదునైన మెమరీ కలిగిన నిర్వహించే ఒకటి మధ్య వ్యత్యాస.

నాలుగు రకాలు, `pipe`/`pipeline` కంపోజిషన్ (మరియు `pipeline` ఎందుకు సురక్షితమైనది) మరియు HTTP విజ్ఞప్తులు/ప్రతిస్పందనలు తమను తాము streams-గా ఉన్నాయని అర్థం చేసుకోవడం Node-లో స్కేలేబుల్ file-handling, data-processing, మరియు proxying సేవలను నిర్మించడానికి అవసరం.