ภายในสตรีมแบบอ่านได้ เขียนได้ สองทาง และแปลงข้อมูล

Node.js streams let you process data piece by piece instead of loading everything into memory at once. This is essential for backend work like serving large files, proxying HTTP bodies, or piping database exports.

• Readable — a source you read FROM (file read, HTTP request)
• Writable — a sink you write TO (file write, HTTP response)
• Duplex — both readable and writable, independent channels (TCP socket)
• Transform — a Duplex where the output is a function of the input (gzip, encryption)

Every one of these is backed by an internal buffer governed by a single number: highWaterMark.

Each stream keeps an internal buffer in its _readableState or _writableState. The highWaterMark (HWM) is the threshold, not a hard limit, at which the stream signals it has buffered "enough".

• Default HWM for byte streams is 16 KB (16384 bytes).
• In object mode the HWM counts objects, defaulting to 16.

When a Readable's buffer fills to the HWM it stops pulling from the source. When a Writable's buffer exceeds the HWM, write() returns false — the signal known as backpressure.

A Readable operates in one of two modes:

• Paused (default): you must call read() explicitly to pull data.
• Flowing: data is pushed at you via 'data' events as fast as it arrives.

Attaching a 'data' listener or calling .pipe() switches the stream into flowing mode. Calling .pause() switches it back. Understanding this is key to controlling memory.

To build your own source, extend Readable and implement _read(size). Inside it you call this.push(chunk) to feed the buffer, and this.push(null) to signal end-of-stream (EOF).

The crucial detail: when push() returns false, the internal buffer has hit the HWM. A well-behaved producer stops pushing until _read is called again.

A Writable buffers incoming chunks and flushes them via _write(chunk, encoding, callback). You MUST call the callback when each chunk is processed — that is how the stream knows to drain its buffer and accept more.

The return value of write() is your backpressure signal:

• true — buffer is below HWM, keep writing.
• false — buffer is at/over HWM, you SHOULD stop and wait for the 'drain' event.

If you ignore a false from write() and keep writing, the internal buffer grows without bound and your process can run out of memory. The correct manual pattern is to pause production until 'drain' fires.

In practice you rarely write this by hand — .pipe() and pipeline() do it for you — but knowing the mechanics explains WHY piping is safe.

readable.pipe(writable) wires a source to a sink and automatically honors backpressure: when the destination returns false, pipe calls source.pause(); on 'drain' it calls source.resume().

The downside of bare .pipe() is error handling: if the source errors, the destination is NOT closed automatically, which can leak file descriptors. Prefer stream.pipeline() in production.

A Duplex stream is both Readable and Writable, but the two sides are independent — what you write does not automatically appear on the read side. A TCP socket is the canonical example: bytes you write go out to the peer, bytes you read come in from the peer.

To implement one, provide both _read and _write. Each side has its own buffer and its own highWaterMark.

A Transform is a special Duplex where the readable side is computed from the writable side. Instead of separate _read/_write, you implement a single _transform(chunk, encoding, callback) and emit results via this.push() or the callback's second argument.

An optional _flush(callback) runs once at the end — perfect for emitting trailing data (e.g. a final checksum or closing bracket).

By default streams move Buffers/strings and the HWM counts bytes. Pass { objectMode: true } and the stream moves arbitrary JS values, with the HWM counting objects instead.

• Byte mode default HWM: 16384 bytes
• Object mode default HWM: 16 objects

This matters for backend pipelines: a Transform parsing NDJSON might read raw bytes (writable side, byte mode) but emit parsed objects (readable side, object mode) using readableObjectMode.

stream.pipeline() chains any number of streams and, unlike .pipe(), it propagates errors and cleans up every stream (destroying them) when any one fails or finishes. This prevents leaked file descriptors and hung sockets.

The promise-based form (require('stream/promises')) integrates cleanly with async/await in route handlers.

You are writing a large dataset to a custom Writable stream in a loop. You want to avoid unbounded memory growth by respecting backpressure. Which signal tells you to stop writing and wait?

You now understand the four stream types and the buffer mechanics behind them:

• Readable — source; implement _read, push data and push(null) for EOF; flowing vs paused modes.
• Writable — sink; implement _write and call its callback; write() returning false means backpressure, wait for 'drain'.
• Duplex — independent read and write channels, each with its own buffer and HWM (e.g. TCP socket).
• Transform — output derived from input via _transform, with optional _flush.

The highWaterMark (16 KB bytes / 16 objects by default) is a threshold, not a hard cap, governing when buffers signal "full". Always prefer pipeline() over bare .pipe() in production for correct error propagation and cleanup.