Menene backpressure a cikin streams kuma ta yaya za ka rike shi?

Question

Accepted Answer

**Backpressure** shine abin da ke faruwa lokacin da aka samar da data **sanadare da ba za a iya cinye ba**. A cikin streams, idan tushen karantawa mai sauri ya tsashe data cikin gida mai tsaurara, data da ba'a ci ba tana wajen ajiya a alaala — kuma ba tare da sarrafa shi ba, buffer yana karu har sai alaala ta karas. Backpressure shine kayan aiki (da alalamun sana'a) don kiye mai samarwa da wai ma tsaye.

## Matsala

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

Almisali: karanta babbar fayil cikin sauri kuma rubuta shi zuwa socket na sabon halitta mai tsaurara ko waje — idan ba ka girmama gudon gida na rubutawa, alaala tana shafar jiya.

## pipe tana sarrafa backpressure ta atomatik

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

Abubuwan da suke nuna amfani don amfani da `pipe`/`pipeline`: suna sarrafa backpressure don ka, taje da maimaita kundin halitta don alaala ta kasance da iyaka ba tare da girma mara iyaka ba.

## Sarrafa shi da hannu tare da iyaka da write() ke koma

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

Idan ka sarrafa streams da hannu, kaida shine: lokacin da `writable.write()` ya koma `false`, **tsaye** karantawa, kuma **maimaita** shi akan writable's `drain` ilin. Ƙin `false` koma shine zacinazabi backpressure jamila.

## Tare da async iteration (sabo, gida)

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

## Gida pipeline don kariya

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

## Menene mahimman

Backpressure shine kasancewa mara gaskiya amma mahimmancin tunanin duniya ga kowane saitin Node-da-saitun data (sarrafa fayil, aiki, streaming, ETL).

Kin shi — ta wajen ajiya komai ko kin ƙin `write()` iyaka — haɗi shi wajen kammala alaala aiki kuma tunkunowa ƙarƙashi kaya, sau da yawa kawai a sarrafa tare da babbar data.

Janye cewa `pipe`/`pipeline` suna sarrafa shi ta atomatik (babbar dalili don gida akai), kuma ta yaya za ka girmama shi da hannu (`false` a tsaye, `drain` a maimaita) ko ta wajen `for await`, shine abin da ke baka samun tsarin streaming da ke zaune tsaye ba tare da bambanta girman ko sauri data ba.

Shine alamar ɗon aiki da streams na maraza.