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 — યોગ્ય ભૂલ સંભાળ સાથે 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()` ને પ્રાધાન્ય છે કારણ કે તે ભૂલો ફેલાવે છે અને દરેક 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 requests/responses તમે જ streams છે તે સમજવું Node માં માપી શકાય તેવી ફાઇલ-હેન્ડલિંગ, ડેટા-પ્રોસેસિંગ, અને પ્રોક્સીિંગ સેવાઓ બનાવવા માટે આવશ્યક છે.