Node.js ਵਿੱਚ streams ਕੀ ਹਨ ਅਤੇ ਤੁਹਾਨੂੰ ਇਹਨਾਂ ਦੀ ਵਰਤੋਂ ਕਦੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ?

Question

Accepted Answer

**Streams** ਡਾਟਾ ਨੂੰ **ਕ੍ਰਮਿਕ ਤੌਰ 'ਤੇ, chunks ਵਿੱਚ** ਪ੍ਰਕਿਰਿਆ ਕਰਦੇ ਹਨ, ਬਜਾਏ ਇਸ ਦੇ ਕਿ ਇਸ ਨੂੰ ਇੱਕ ਵਾਰ ਵਿੱਚ ਮੈਮੋਰੀ ਵਿੱਚ ਲੋਡ ਕਰੋ। ਇਹ ਵੱਡੇ ਡਾਟਾ (ਵੱਡੀਆਂ ਫਾਈਲਾਂ, ਨੈਟਵਰਕ ਟ੍ਰਾਂਸਫਰ) ਲਈ ਜ਼ਰੂਰੀ ਹਨ ਜਿਥੇ ਸਭ ਕੁਝ buffer ਕਰਨਾ ਮੈਮੋਰੀ ਖਤਮ ਕਰ ਦਿੰਦਾ ਹੈ।

## ਸਮੱਸਿਆ ਜੋ 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 ਨਾਲ, ਮੈਮੋਰੀ ਦੀ ਵਰਤੋਂ ਫਾਈਲ ਦੀ ਸਾਈਜ਼ ਦੀ ਪ੍ਰਵਾਹ ਕੀ ਪਰਵਾਹ ਕੀਤੇ ਬਗੈਰ ਸਮਾਨ ਰਹਿਂਦੀ ਹੈ — ਤੁਸੀਂ ਇੱਕ ਸਮੇਂ ਇੱਕ chunk ਨੂੰ ਸੰਭਾਲਦੇ ਹੋ।

## ਚਾਰ stream types

```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 ਨੂੰ compose ਕਰਨ ਦਾ idiomatic ਤਰੀਕਾ।

## pipeline — ਸਠੀਕ error handling ਦੇ ਨਾਲ 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` chained `.pipe()` ਨਾਲੋਂ ਬਿਹਤਰ ਹੈ ਕਿਉਂਕਿ ਇਹ errors ਨੂੰ propagate ਕਰਦਾ ਹੈ ਅਤੇ ਹਰ 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 ਵੱਡੇ ਜਾ ਲਗਾਤਾਰ ਡਾਟਾ ਦੀ **memory-efficient** ਪ੍ਰਕਿਰਿਆ ਲਈ ਇੱਕ ਪਰਿਭਾਸ਼ਿਤ Node ਫਿਚਰ ਹਨ — ਇੱਕ ਵੱਡੀ upload 'ਤੇ ਕ੍ਰੈਸ਼ ਹੋਣ ਵਾਲੀ ਐਪਲੀਕੇਸ਼ਨ ਅਤੇ ਇੱਕ ਜੋ ਸਮਾਨ ਮੈਮੋਰੀ ਨਾਲ ਕਿਸੇ ਵੀ ਸਾਈਜ਼ ਨੂੰ ਸੰਭਾਲ ਸਕਦੀ ਹੈ ਵਿਚਕਾਰ ਅੰਤਰ।

ਚਾਰ types, `pipe`/`pipeline` composition (ਅਤੇ ਕਿਉਂ `pipeline` ਵਧੇਰੇ ਸੁਰੱਖਤ ਹੈ), ਅਤੇ ਇਹ ਕਿ HTTP requests/responses ਆਪਣੇ ਆਪ streams ਹਨ ਨੂੰ ਸਮਝਣਾ Node ਵਿੱਚ scalable file-handling, data-processing, ਅਤੇ proxying services ਬਣਾਉਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।