સ્ટ્રીમમાં બેકપ્રેશર શું છે અને તમે તેને કેવી રીતે સંભાળો છો?

Question

Accepted Answer

**બેકપ્રેશર** એ છે જે થાય છે જ્યારે ડેટા **તેનો વપરાશ કરી શકાય તેના કરતાં વધુ ઝડપથી** ઉત્પાદિત થાય છે. સ્ટ્રીમમાં, જો ઝડપી વાંચનીય સ્ત્રોત ધીમા લખાણયોગ્ય ગંતવ્યમાં ડેટા દાખલ કરે, તો અવપણન ડેટા મેમરીમાં બફર થાય છે — અને હેન્ડલિંગ વિના, તે બફર મેમરી ખતમ થઈ જાય છે ત્યાં સુધી વધે છે. બેકપ્રેશર એ મેકેનિజમ (અને શાખા) છે જે નિર્માતા અને ઉપભોક્તાને સંતુલનમાં રાખે છે.

## સમસ્યા

```text
Fast source ──(1 GB/s)──▶ Slow destination (10 MB/s write speed)
                          ▲
             The 990 MB/s difference piles up in a memory buffer → OOM crash
```

ઉદાહરણ: વિશાળ ફાઇલ ઝડપથી વાંચવું અને તેને ધીમા નેટવર્ક સોકેટ અથવા ડિસ્કમાં લખવું — જો તમે ગંતવ્યના ગતિને માન આપતા નથી, તો મેમરી ફુલ્લાવવામાં આવે છે.

## pipe આપોઆપ બેકપ્રેશર સંભાળે છે

```js
import { createReadStream, createWriteStream } from "fs";

// ✅ pipe automatically pauses the source when the destination is full,
//    and resumes it when the destination drains — backpressure handled for you
createReadStream("huge.file").pipe(createWriteStream("copy.file"));
```

હોય તે મુખ્ય કારણ છે `pipe`/`pipeline` વાપરવું: તેઓ તમારી માટે બેકપ્રેશર સંચાલિત કરે છે, પ્રવાહને અટકાવે છે અને恢復 કરે છે જેથી મેમરી કદ મેળ વિના સીમાબદ્ધ રહે છે.

## write()'s વળતર મૂલ્ય સાથે જાતે સંભાળવું

```js
// write() returns FALSE when the internal buffer is full — that's the backpressure signal
readable.on("data", (chunk) => {
  const ok = writable.write(chunk);
  if (!ok) {
    readable.pause();                       // stop reading — destination is full
    writable.once("drain", () => readable.resume()); // resume when it drains
  }
});
```

જો તમે સ્ટ્રીમને જાતે હેન્ડલ કરો છો, તો નિયમ છે: જ્યારે `writable.write()` `false` આપે છે, **વાંચનીયને અટકાવો**, અને તેને writable's `drain` ઇવેન્ટ પર **પુનરાવર્તન કરો**. `false` વળતરને અવગણવું એ શાસ્ત્રીય બેકપ્રેશર ભૂલ છે.

## async iteration સાથે (આધુનિક, સ્વચ્છ)

```js
// for-await respects backpressure naturally — it awaits each chunk's processing
for await (const chunk of readable) {
  await processSlowly(chunk); // only pulls the next chunk when ready
}
```

## સુરક્ષા માટે pipeline પસંદ કરો

```js
import { pipeline } from "stream/promises";
await pipeline(source, transform, destination); // backpressure + error handling + cleanup
```

## શા માટે તેનો મહત્વ છે

બેકપ્રેશર એ સુક્ષ્મ પરંતુ નિર્ણાયક ખ્યાલ છે કોઈપણ ડેટા-સઘન Node સેવા માટે (ફાઇલ પ્રોસેસિંગ, પ્રોક્સીંગ, સ્ટ્રીમિંગ, ETL).

તેને અવગણવું — બધું બફર કરીને અથવા `write()`'s વળતર મૂલ્યને અવગણીને — અનબાઉન્ડેડ મેમરી વૃદ્ધિ અને લોડ હેઠળ ક્રેશ કરે છે, ઘણીવાર માત્ર ઉત્પાદનમાં મોટા ડેટા સાથે.

સમજવું કે `pipe`/`pipeline` આપોઆપ તેને હેન્ડલ કરે છે (તેમને પસંદ કરવાનું મુખ્ય કારણ), અને તેને જાતે કેવી રીતે માન આપવું તે (`false` પર અટકાવો, `drain` પર પુનરાવર્તન કરો) અથવા `for await` દ્વારા, તે છે જે તમને સ્ટ્રીમિંગ સિસ્ટમ બાંધવા દે છે જે ડેટા ગમે તેટલું મોટું અથવા ઝડપી હોય તો પણ મેમરી-સ્થિર રહે છે.

તે સ્ટ્રીમ વપરાશના સક્ષમ નિશાનીની વ્યાખ્યા આપે છે.