Node.js-இல் streams என்றால் என்ன மற்றும் எப்போது அவற்றைப் பயன்படுத்த வேண்டும்?

Question

Accepted Answer

**Streams** தரவை **படிப்படியாக, chunks-ல்** செயல்படுத்துகிறது, அனைத்தையும் ஒரே நேரத்தில் நினைவாக ஏற்றுவதற்குப் பதிலாக. இது பெரிய தரவு (பெரிய கோப்புகள், நெட்வொர்க் பரிமாற்றம்) அவசியமாகிறது, அங்கு எல்லாவற்றையும் பஃபர் செய்வது நினைவை முடிந்துவிடும்.

## 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 வகைகள்

```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 உடன் இடையில்), தானாக flow-ஐ நிர்வகிக்கிறது — streams-ஐ தொகுப்பதற்கான மரபுசாரமான வழி.

## 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-ஐ பரப்புகிறது மற்றும் ஒவ்வொரு 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 என்பது **நினைவு-திறமையான** பெரிய அல்லது தொடர்ச்சியான தரவு கையாளுதலுக்கான Node இன் வரையறுக்கும் அம்சம் — ஒரு பெரிய பதிவேற்றத்தில் செயலிழக்கும் ஆப்பின் வேறுபாடு மற்றும் ஒன்றுக்கு தட்ட நினைவு கொண்டு எந்த அளவையும் கையாளும்.

நான்கு வகைகள், `pipe`/`pipeline` தொகுப்பு (மற்றும் `pipeline` ஏன் பாதுகாப்பான) மற்றும் HTTP கோரிக்கைகள்/பதிலுகள் தங்களை streams-ஆக இருக்கின்றன என்பது புரிந்துகொள்வது Node-இல் அளவிடக்கூடிய file-handling, data-processing, மற்றும் proxying சேவைகளை உருவாக்க அவசியமாகும்.