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.

Practice

1. What is the main purpose of a Writable stream in Node.js?

easy

A. To send data piece by piece to a destination

B. To read data from a file

C. To create a server

D. To handle HTTP requests

Solution

1. Step 1: Understand Writable stream role

   Writable streams are designed to send data to a destination in chunks.

2. Step 2: Compare with other options

   Reading data is done by Readable streams, not Writable. Creating servers and handling HTTP requests are unrelated to Writable streams.

3. Final Answer:

   To send data piece by piece to a destination -> Option A

4. Quick Check:

   Writable stream = send data [OK]

Hint: Writable streams send data out chunk by chunk [OK]

Common Mistakes:

• Confusing Writable with Readable streams
• Thinking Writable streams read data
• Mixing streams with server creation

2. Which of the following is the correct way to implement the _write method in a custom Writable stream?

easy

A. _write(chunk, encoding, callback) { callback(); }

B. _write(chunk, encoding) { return chunk; }

C. _write(chunk) { console.log(chunk); }

D. _write() { return true; }

Solution

1. Step 1: Recall _write method signature

   The _write method must accept three parameters: chunk, encoding, and callback.

2. Step 2: Check callback usage

   Calling callback() signals that the chunk was processed. Omitting it causes the stream to hang.

3. Final Answer:

   _write(chunk, encoding, callback) { callback(); } -> Option A

4. Quick Check:

   _write needs callback() [OK]

Hint: Always include callback in _write and call it [OK]

Common Mistakes:

• Forgetting the callback parameter
• Not calling callback inside _write
• Wrong number of parameters in _write

3. Consider this code snippet:

const { Writable } = require('stream');
class MyStream extends Writable {
  _write(chunk, encoding, callback) {
    console.log(chunk.toString());
    callback();
  }
}
const stream = new MyStream();
stream.write('Hello');
stream.end('World');

What will be printed to the console?

medium

A. HelloWorld

B. Hello\nWorld

C. Hello\nWorld\n

D. Hello\nWorld printed separately

Solution

1. Step 1: Understand write and end calls

   stream.write('Hello') sends 'Hello' chunk, then stream.end('World') sends 'World' chunk and ends.

2. Step 2: Check _write behavior

   Each chunk is logged separately with console.log, so 'Hello' and 'World' print on separate lines.

3. Final Answer:

   Hello World printed separately -> Option D

4. Quick Check:

   Each chunk logs separately [OK]

Hint: Each write chunk logs on its own line [OK]

Common Mistakes:

• Assuming chunks concatenate automatically
• Expecting no newline between chunks
• Confusing write and end data handling

4. What is wrong with this Writable stream implementation?

const { Writable } = require('stream');
class BrokenStream extends Writable {
  _write(chunk, encoding) {
    console.log(chunk.toString());
  }
}
const stream = new BrokenStream();
stream.write('Test');

medium

A. Using console.log inside _write is not allowed

B. Missing callback parameter and not calling callback()

C. Not calling stream.end() causes error

D. _write method should be named write

Solution

1. Step 1: Check _write method signature

   _write must have three parameters: chunk, encoding, callback.

2. Step 2: Check callback usage

   Callback must be called to signal completion; missing callback causes stream to hang.

3. Final Answer:

   Missing callback parameter and not calling callback() -> Option B

4. Quick Check:

   _write needs callback param and call [OK]

Hint: Always include and call callback in _write [OK]

Common Mistakes:

• Omitting callback parameter
• Not calling callback inside _write
• Confusing _write with write method

5. You want to create a Writable stream that collects all written chunks into a single string and logs it only when the stream ends. Which approach is correct?

hard

A. Log each chunk inside _write and ignore 'finish' event

B. Call callback only after all chunks are written, ignoring _write

C. Store chunks in a variable inside _write, call callback, then log in 'finish' event

D. Use readable stream instead of writable for collecting data

Solution

1. Step 1: Collect chunks inside _write

   Inside _write, append each chunk to a variable and call callback to continue.

2. Step 2: Log combined data on 'finish' event

   Listen to the 'finish' event to know when writing ends, then log the full collected string.

3. Final Answer:

   Store chunks in a variable inside _write, call callback, then log in 'finish' event -> Option C

4. Quick Check:

   Collect chunks + log on finish = Store chunks in a variable inside _write, call callback, then log in 'finish' event [OK]

Hint: Collect chunks in _write, log on 'finish' event [OK]

Common Mistakes:

• Logging inside _write causing multiple logs
• Not calling callback causing stream to hang
• Using readable stream instead of writable