Node.js में streams क्या हैं और आपको उनका उपयोग कब करना चाहिए?

Question

Accepted Answer

**Streams** डेटा को **वृद्धिशील रूप से, chunks में** प्रोसेस करते हैं, बजाय इसके कि सभी को एक बार में मेमोरी में लोड करें। यह बड़े डेटा (बड़ी फाइलें, नेटवर्क ट्रांसफर) के लिए आवश्यक है जहाँ सब कुछ buffer करने से मेमोरी समाप्त हो जाएगी।

## समस्या जो 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 के साथ, मेमोरी उपयोग फाइल आकार की परवाह किए बिना समतल रहता है — आप एक बार में एक chunk को संभालते हैं।

## चार 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 को compose करने का आदर्श तरीका।

## 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` chained `.pipe()` से अधिक पसंद किया जाता है क्योंकि यह errors को propagate करता है और प्रत्येक 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 की परिभाषित विशेषता है — एक ऐसे ऐप के बीच अंतर जो बड़े अपलोड पर crash करेगा और एक जो किसी भी आकार को समतल मेमोरी के साथ संभालता है।

चार प्रकारों, `pipe`/`pipeline` composition को समझना (और क्यों `pipeline` सुरक्षित है), और यह कि HTTP requests/responses स्वयं streams हैं, Node में scalable file-handling, data-processing, और proxying सेवाएं बनाने के लिए आवश्यक है।