Reading data with Readable streams in Node.js - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the Readable stream module.

Node.js

const { [1] } = require('stream');

Drag options to blanks, or click blank then click option'

AReadable

BWritable

CTransform

DDuplex

Attempts:

3 left

💡 Hint

Common Mistakes

Choosing Writable which is for writing data.

Choosing Transform or Duplex which are for other stream types.

The Readable class is imported from the stream module to create readable streams.

2fill in blank

medium

Complete the code to create a readable stream from an array of strings.

Node.js

const readable = Readable.from([1]);

Drag options to blanks, or click blank then click option'

A['hello', 'world']

B{hello: 'world'}

C'hello world'

D12345

Attempts:

3 left

💡 Hint

Common Mistakes

Passing a single string instead of an array.

Passing an object which is not iterable.

Passing a number which is invalid.

The Readable.from() method creates a readable stream from an iterable like an array of strings.

3fill in blank

hard

Fix the error in the code to read data chunks from the stream.

Node.js

readable.on('data', ([1]) => {
  console.log(chunk.toString());
});

Drag options to blanks, or click blank then click option'

Abuffer

Bdata

Cchunk

Dstream

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different parameter name than the one used inside the function.

Using a reserved word like 'data' as parameter but not matching usage.

The callback parameter name must match the variable used inside the function. Here, chunk is used to log the data.

4fill in blank

hard

Fill both blanks to correctly handle the end of the readable stream.

Node.js

readable.on('[1]', () => {
  console.log('[2]');
});

Drag options to blanks, or click blank then click option'

Aend

Bfinish

Cclose

Dend of stream reached

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'finish' which is for writable streams.

Using 'data' which is for data chunks.

Using 'close' which is different and less common here.

The end event signals that no more data will be provided by the stream. Logging a message inside this event handler informs the user.

5fill in blank

hard

Fill all three blanks to create a readable stream and log all data chunks and the end event.

Node.js

const { [1] } = require('stream');

const data = ['Node', 'JS', 'Streams'];
const readable = [2].from(data);

readable.on('data', ([3]) => {
  console.log([3].toString());
});

Drag options to blanks, or click blank then click option'

AReadable

Cchunk

Dbuffer

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for import and usage.

Using wrong parameter names in the event handler.

Not calling from() on the Readable class.

First, import Readable. Then create a readable stream from the array data using Readable.from(). Finally, listen to the 'data' event with a parameter chunk to log each data piece.

Practice

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

easy

A. To create a new HTTP server

B. To read data piece by piece without loading it all at once

C. To execute JavaScript code asynchronously

D. To write data to a file all at once

Solution

1. Step 1: Understand what a Readable stream does

   A Readable stream reads data in small chunks instead of loading everything at once, which helps save memory.

2. Step 2: Compare options with the purpose

   Only To read data piece by piece without loading it all at once describes reading data piece by piece, which matches the purpose of Readable streams.

3. Final Answer:

   To read data piece by piece without loading it all at once -> Option B

4. Quick Check:

   Readable stream = read data in chunks [OK]

Hint: Readable streams read data bit by bit, not all at once [OK]

Common Mistakes:

• Confusing Readable streams with writing data
• Thinking streams execute code
• Mixing streams with server creation

2. Which of the following is the correct way to listen for data chunks from a Readable stream named stream?

easy

A. stream.on('data', chunk => { console.log(chunk); });

B. stream.emit('data', chunk => { console.log(chunk); });

C. stream.read('data', chunk => { console.log(chunk); });

D. stream.listen('data', chunk => { console.log(chunk); });

Solution

1. Step 1: Recall the event listening method in Node.js streams

   To listen for events, use the on method with the event name and a callback function.

2. Step 2: Match the correct syntax

   stream.on('data', chunk => { console.log(chunk); }); uses stream.on('data', callback), which is the correct way to listen for data chunks.

3. Final Answer:

   stream.on('data', chunk => { console.log(chunk); }); -> Option A

4. Quick Check:

   Use .on() to listen to stream events [OK]

Hint: Use .on('data', callback) to read chunks from streams [OK]

Common Mistakes:

• Using emit instead of on to listen
• Using non-existent methods like read or listen
• Confusing event listening with emitting

3. What will the following code output if the file example.txt contains the text "Hello World"?

const fs = require('fs');
const stream = fs.createReadStream('example.txt');
stream.on('data', chunk => {
  console.log(chunk.toString());
});
stream.on('end', () => {
  console.log('Done reading');
});

medium

A. Hello World
Done reading

B. Buffer data
Done reading

C. Hello WorldDone reading

D. SyntaxError

Solution

1. Step 1: Understand the stream reading process

   The stream reads the file in chunks and emits 'data' events. Each chunk is a Buffer, converted to string with toString().

2. Step 2: Analyze the output

   The console logs the text "Hello World" followed by a newline, then logs "Done reading" when the stream ends.

3. Final Answer:

   Hello World Done reading -> Option A

4. Quick Check:

   Stream reads text chunks and logs 'Done reading' at end [OK]

Hint: Streams emit 'data' chunks as Buffers; convert to string to read [OK]

Common Mistakes:

• Expecting raw Buffer output without conversion
• Missing the 'end' event message
• Confusing output formatting

4. Identify the error in this code snippet that reads data from a stream:

const fs = require('fs');
const stream = fs.createReadStream('file.txt');
stream.on('data', (chunk) => {
  console.log(chunk);
});
stream.on('finish', () => {
  console.log('Stream finished');
});

medium

A. The 'data' event callback is missing a parameter

B. The stream should be paused before reading

C. The 'finish' event does not exist on Readable streams

D. The file path must be absolute

Solution

1. Step 1: Check event names for Readable streams

   Readable streams emit 'end' when done, not 'finish'. 'finish' is for Writable streams.

2. Step 2: Identify the incorrect event usage

   The code listens for 'finish', which will never fire on a Readable stream, causing the message to never appear.

3. Final Answer:

   The 'finish' event does not exist on Readable streams -> Option C

4. Quick Check:

   Readable streams use 'end', not 'finish' event [OK]

Hint: 'finish' is for writing; use 'end' for reading streams [OK]

Common Mistakes:

• Using 'finish' event on Readable streams
• Forgetting to handle 'end' event
• Assuming 'data' event has no parameters

5. You want to read a large file using a Readable stream and count how many times the word "node" appears, case-insensitive. Which approach correctly handles data chunks to count occurrences without missing matches across chunk boundaries?

hard

A. Convert each chunk to string and count occurrences immediately, ignoring chunk edges

B. Count occurrences in each chunk separately without storing leftover text

C. Use a writable stream instead of a readable stream for counting

D. Concatenate chunks into a string, then count occurrences after 'end' event

Solution

1. Step 1: Understand chunk boundaries in streams

   Chunks may split words, so counting in each chunk separately can miss matches that cross chunk edges.

2. Step 2: Choose a method to avoid missing matches

   Concatenating all chunks into one string and counting after the 'end' event ensures all occurrences are counted correctly.

3. Final Answer:

   Concatenate chunks into a string, then count occurrences after 'end' event -> Option D

4. Quick Check:

   Count after full data read to avoid split word misses [OK]

Hint: Join chunks first, then count words to avoid split matches [OK]

Common Mistakes:

• Counting words in each chunk ignoring splits
• Using writable streams for reading tasks
• Not handling case-insensitive matching