Writing data with Writable streams in Node.js - Step-by-Step Execution

Concept Flow - Writing data with Writable streams

Create Writable Stream

↓

Call write(data)

↓

Data buffered?

Yes→Buffer data

↓

Wait for drain event

↓

Send data to destination

↓

Call callback or emit 'finish'

↓

Call end() to finish stream

This flow shows how data is written to a Writable stream: data is written, buffered if needed, sent to destination, and the stream ends.

Execution Sample

Node.js

const { Writable } = require('stream');
const writable = new Writable({
  write(chunk, encoding, callback) {
    console.log(chunk.toString());
    callback();
  }
});
writable.write('Hello');
writable.end();

This code creates a Writable stream that logs written data, writes 'Hello', then ends the stream.

Execution Table

Step	Action	Data Chunk	Buffer State	Callback Called	Output
1	Create Writable stream	-	Empty	No	-
2	Call write('Hello')	'Hello'	Empty or buffered if slow	No yet	-
3	write() method logs chunk	'Hello'	Empty	Yes	Console logs 'Hello'
4	Call end()	-	Empty	No	-
5	Stream finishes	-	Empty	Yes	Stream closed

💡 Stream ends after end() is called and all data is flushed

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
Buffer	Empty	Possibly holds 'Hello' if slow	Empty after write callback	Empty	Empty
Callback Called	No	No	Yes	No	Yes

Key Moments - 3 Insights

Why does the write() method take a callback?

The callback signals when the chunk is processed and the stream is ready for more data, as shown in step 3 of the execution_table.

What happens if write() is called faster than data can be sent?

Data is buffered internally until the stream drains, as indicated in step 2's 'Buffer State' in the execution_table.

Why do we call end() after writing data?

Calling end() tells the stream no more data will come and triggers the 'finish' event, shown in steps 4 and 5.

Visual Quiz - 3 Questions

Look at the execution_table, at which step is the write callback called?

A Step 3

B Step 2

C Step 4

D Step 5

💡 Hint

Check the 'Callback Called' column in the execution_table rows

According to variable_tracker, what is the buffer state after step 3?

A Undefined

B Empty

C Holds 'Hello'

D Full

💡 Hint

Look at the 'Buffer' row and 'After Step 3' column in variable_tracker

If we remove the callback call inside write(), what happens to the stream?

A Stream ends normally

B Data is lost immediately

C Stream never signals ready for more data

D Write throws an error

💡 Hint

Recall the purpose of the callback in the write() method from key_moments and execution_table

Concept Snapshot

Writable streams let you send data chunk by chunk.
Use write(data, callback) to send data.
Callback signals when ready for more.
end() closes the stream after all data is sent.
Data may be buffered if destination is slow.

Full Transcript

Writable streams in Node.js allow you to send data in pieces called chunks. You create a Writable stream by defining a write method that handles each chunk. When you call write(data), the stream may buffer the data if it cannot send it immediately. The write method takes a callback that you call when the chunk is processed, signaling the stream is ready for more data. After writing all data, you call end() to close the stream. This process ensures data flows smoothly without loss or overload.