streams मा backpressure के हो र तपाइँ यसलाई कसरी सम्हाल्नु हुन्छ?

Question

Accepted Answer

**Backpressure** तब हुन्छ जब डेटा **उपभोग गर्न सक्ने भन्दा बिलकुल छिटो उत्पादित हुन्छ**। streams मा, यदि द्रुत readable स्रोतले slow writable गन्तव्यमा डेटा पुश गर्छ भने, unconsumed डेटा मेमोरीमा buffer हुन्छ — र ह्यान्डलिङ् बिना, त्यो buffer बढ्दै जान्छ जबसम्म मेमोरी समाप्त नहुन्छ। Backpressure यो मेकानिजम (र अनुशासन) हो जो producer र consumer लाई सन्तुलनमा राख्छ।

## समस्या

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

उदाहरण: ठूलो फाइल छिटो पढ्ने र यसलाई slow network socket वा disk मा लेख्ने — यदि तपाइँले गन्तव्यको गति सम्मान गर्नुहुन्न भने, मेमोरी बढ्छ।

## pipe ले backpressure स्वचालित रूपमा ह्यान्डल गर्छ

```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` प्रयोग गर्नुको मुख्य कारण हो: तिनीहरूले backpressure तपाइँको लागि व्यवस्थापन गर्छन्, flow लाई pause र resume गर्छन् ताकि मेमोरी size mismatch को परवाह नगरी bounded रहन्छ।

## write() को return value को साथ म्यानुयली ह्यान्डल गरिन्छ

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

यदि तपाइँ streams म्यानुयली ह्यान्डल गर्नु हुन्छ भने, नियम यो हो: जब `writable.write()` ले `false` return गर्छ, **readable लाई pause गर्नु** र writable को `drain` event मा यसलाई **resume गर्नु**। `false` return लाई अनदेखा गर्नु यो क्लासिक backpressure bug हो।

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

## यो किन महत्त्वपूर्ण छ

Backpressure एक सूक्ष्म तर महत्त्वपूर्ण अवधारणा हो कुनै पनि डेटा-गहन Node सेवाको लागि (फाइल processing, proxying, streaming, ETL)।

यसलाई अनदेखा गर्नु — सबै कुरा buffer गरेर वा `write()` को return value लाई अनदेखा गरेर — unbounded मेमोरी वृद्धि र load अन्तर्गत crashes को कारण बनाउँछ, प्रायः production मा मात्र ठूलो डेटा को साथ।

बुझ्नु कि `pipe`/`pipeline` ले यसलाई स्वचालित रूपमा ह्यान्डल गर्छन् (तिनीहरूलाई प्राथमिकता दिनुको मुख्य कारण), र यसलाई म्यानुयली कसरी सम्मान गर्ने (pause on `false`, resume on `drain`) वा `for await` मार्फत, यो तपाइँलाई streaming systems निर्माण गर्न सक्षम बनाउँछ जो डेटा कति ठूलो वा छिटो भएता पनि मेमोरी-स्थिर रहन्छ।

यो कुशल stream usage को परिभाषित चिन्ह हो।