Menene streams a Node.js da kuma lokacin da ya kamata ka yi amfani da su?

Question

Accepted Answer

**Streams** suna aiki da bayani **da karfi, a katon-katon**, maimakon loda shi duka a ciki alaƙar a lokaci daya. Wannan shi ne daidai da manyan bayani (manyan fayiloli, aika sadarwa) inda da kunshe komai zai amfani da alaƙar.

## Matsala da streams ke warware

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

Tare da streams, amfani da alaƙar ya tsaya daidai ko da girman fayil ya bambanta — ka dandanata ɗaya-ɗaya kawai.

## Nau'ukan streams guda hudu

```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 — tunka 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` yana haɗa readable zuwa writable (tare da sauye-sauye a tsakiya), na sarrafa kwararar sadarwa a kai tsaye — hanya daidaitacciyar tunka streams.

## pipeline — pipe tare da kyakkyawan sa mallakar kuskure

```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` ya fi dacewa fiye da `.pipe()` da aka hade da jiya saboda yana yada kuskure da sarrafa kowane stream daidai.

## Inda streams suka bayyana

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

## Lokacin da ba za a dama ba

```text
Small data that fits comfortably in memory → readFile/simple buffering is simpler.
Streams add complexity; use them for LARGE or continuous data.
```

## Menene mahaimmanci

Streams shine fasalin Node don **aiki mai ƙarfi" na manyan bayani ko ci gaba na bayani — bambancin tsakanin app da zai fashe akan babbar aika da daya da ke jiya kowanne girma tare da alaƙar mai kwanciyar hankali.

Sanin nau'ukan hudu, `pipe`/`pipeline` tunka (da kuma dalilin `pipeline` ya fi aminci), da cewa HTTP bukatu/amsa ni kansu streams ya zama daidai don gina aiki mai ƙarfi na jiya fayiloli, aiki na bayani, da aiki mai waje a Node.