Hva er strømmer (streams) i Node.js og når bør du bruke dem?

Question

Accepted Answer

**Strømmer** behandler data **inkrementelt, i biter**, i stedet for å laste alt inn i minnet på en gang. Dette gjør dem essensielle for store datamengder (store filer, nettverksoverføringer) der buffering av alt ville oppbruke minnet.

## Problemet strømmer løser

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

Med strømmer forblir minnebruken flat uavhengig av filstørrelse — du håndterer en bit av gangen.

## De fire strømtypene

```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 — koble sammen strømmer

```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` forbinder en lesbar strøm til en skrivbar strøm (med transformasjoner i mellom), og håndterer flyten automatisk — den idiomatiske måten å komponere strømmer på.

## pipeline — pipe med riktig feilhåndtering

```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` foretrekkes over kjettede `.pipe()` fordi det formidler feil og rydder opp i hver strøm korrekt.

## Hvor strømmer vises

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

## Når du IKKE trenger å bry deg

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

## Hvorfor det betyr noe

Strømmer er en definerende Node-funksjon for **minneeffektiv** håndtering av store eller kontinuerlige data — forskjellen mellom en app som krasjer ved en stor opplasting og en som håndterer hvilken som helst størrelse med flatt minnebruk.

Å forstå de fire typene, `pipe`/`pipeline`-komposisjon (og hvorfor `pipeline` er sikrere), og at HTTP-forespørsler/svar selv er strømmer, er essensielt for å bygge skalérbare fil-håndterings-, databehandlings- og proxying-tjenester i Node.