Writing data with Writable streams in Node.js - Mini Project: Build & Apply

Writing data with Writable streams

📖 Scenario: You are building a simple Node.js program that writes some text data to a file using a writable stream. This is useful when you want to save logs or output data efficiently.

🎯 Goal: Create a writable stream to a file called output.txt and write three lines of text data to it using the stream's write method. Then close the stream properly.

📋 What You'll Learn

Create a writable stream to a file named output.txt

Write exactly these three lines to the stream: 'First line\n', 'Second line\n', 'Third line\n'

Close the writable stream using the end() method

💡 Why This Matters

🌍 Real World

Writable streams are used in Node.js to efficiently write data to files, network sockets, or other destinations without loading everything into memory at once.

💼 Career

Understanding writable streams is important for backend developers working with file systems, logging, or streaming data in Node.js applications.

1

Create a writable stream

Write a line to import the fs module and create a writable stream called writeStream that writes to a file named output.txt.

Node.js

const fs = require('fs');
// Create a writable stream called writeStream to 'output.txt'
// Your code here

Hint

Use require('fs') to import the file system module. Then use fs.createWriteStream('output.txt') to create the stream.

2

Write the first line to the stream

Use the writeStream.write() method to write the string 'First line\n' to the stream.

Node.js

const fs = require('fs');
const writeStream = fs.createWriteStream('output.txt');
// Write 'First line\n' to writeStream
// Your code here

Hint

Call writeStream.write() with the exact string 'First line\n'.

3

Write the second and third lines

Write the strings 'Second line\n' and 'Third line\n' to writeStream using the write() method twice.

Node.js

const fs = require('fs');
const writeStream = fs.createWriteStream('output.txt');
writeStream.write('First line\n');
// Write 'Second line\n' and 'Third line\n' to writeStream
// Your code here

Hint

Call writeStream.write() two more times with the exact strings 'Second line\n' and 'Third line\n'.

4

Close the writable stream

Call the end() method on writeStream to close the stream properly.

Node.js

const fs = require('fs');
const writeStream = fs.createWriteStream('output.txt');
writeStream.write('First line\n');
writeStream.write('Second line\n');
writeStream.write('Third line\n');
// Close the writeStream
// Your code here

Hint

Use writeStream.end() to close the stream after writing.

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