Streams vs loading entire file in memory in Node.js - Practice Questions

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why use streams instead of loading entire files?

Which of the following best explains why streams are preferred over loading an entire file into memory in Node.js?

A Streams allow processing data piece by piece, reducing memory usage for large files.

B Streams automatically compress files to save disk space.

C Loading entire files is faster and uses less CPU than streams.

D Streams require the entire file to be loaded before processing starts.

💡 Hint

Think about memory use when files are very large.

Streams process data in chunks, so they don't need to load the whole file at once. This saves memory especially for big files.

❓ component_behavior

intermediate

What happens when reading a large file with streams?

Given this Node.js code snippet using streams, what will be the output behavior?

Node.js

const fs = require('fs');
const stream = fs.createReadStream('largefile.txt');
stream.on('data', chunk => {
  console.log('Received chunk of size:', chunk.length);
});
stream.on('end', () => {
  console.log('Finished reading file');
});

A Reads the entire file at once and logs one chunk size.

B Logs 'Finished reading file' immediately, then logs chunk sizes.

C Throws an error because 'data' event is not supported on streams.

D Logs multiple 'Received chunk of size:' messages as data arrives, then logs 'Finished reading file'.

💡 Hint

Streams emit 'data' events multiple times as chunks arrive.

The 'data' event fires repeatedly for each chunk. After all chunks are read, the 'end' event fires.

📝 Syntax

advanced

Identify the error in this stream reading code

What error will this Node.js code produce when trying to read a file using streams?

Node.js

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

A No error; logs file content and 'Done reading'.

B SyntaxError due to missing semicolon.

C Error: 'finish' event does not exist on readable streams.

D TypeError because chunk is undefined.

💡 Hint

Check if 'finish' is the right event for reading streams.

The 'finish' event is for writable streams. Readable streams emit 'end' when done.

❓ state_output

advanced

Memory usage difference between streams and full file read

If you read a 1GB file using fs.readFile versus fs.createReadStream, what is the expected memory usage behavior?

A Both use the same memory because Node.js caches files automatically.

B fs.readFile uses much more memory because it loads the entire file; streams use less memory by processing chunks.

C Streams use more memory because they keep multiple chunks in memory at once.

D fs.readFile uses less memory because it reads faster.

💡 Hint

Think about how much data is held in memory at once.

fs.readFile loads the whole file into memory, which can be large. Streams handle small parts at a time, saving memory.

🔧 Debug

expert

Why does this stream pipeline hang without output?

Consider this Node.js code that reads a file and writes to another file using streams. Why does it hang without finishing?

Node.js

const fs = require('fs');
const readStream = fs.createReadStream('input.txt');
const writeStream = fs.createWriteStream('output.txt');
readStream.pipe(writeStream);
// No event handlers attached

A The code is correct; it should finish but no logs show because no events are handled.

B The writeStream is not closed, so the process waits indefinitely.

C The readStream is not paused, causing a deadlock.

D The pipe method is missing a callback to start the flow.

💡 Hint

Think about what happens if no logs or events are used.

The pipe works and copies data, but without event handlers, you won't see output or know when it finishes. The process ends when streams close.

Practice

1. What is the main advantage of using streams in Node.js instead of loading an entire file into memory?

easy

A. Streams load the entire file faster than reading all at once.

B. Streams require less code to read files than other methods.

C. Streams automatically compress files during reading.

D. Streams process data in small chunks, saving memory.

Solution

1. Step 1: Understand how streams work

   Streams read data piece by piece, not all at once, which uses less memory.

2. Step 2: Compare with loading entire file

   Loading entire file reads all data into memory, which can be heavy for big files.

3. Final Answer:

   Streams process data in small chunks, saving memory. -> Option D

4. Quick Check:

   Streams = small chunks, less memory [OK]

Hint: Streams handle data bit by bit, saving memory [OK]

Common Mistakes:

• Thinking streams load files faster always
• Believing streams compress data automatically
• Assuming streams require less code always

2. Which of the following is the correct way to create a readable stream for a file named data.txt in Node.js?

easy

A. const stream = fs.createReadStream('data.txt');

B. const stream = fs.readFile('data.txt');

C. const stream = fs.openStream('data.txt');

D. const stream = fs.streamFile('data.txt');

Solution

1. Step 1: Recall Node.js stream syntax

   The correct method to create a readable stream is fs.createReadStream(filename).

2. Step 2: Check each option

   Only const stream = fs.createReadStream('data.txt'); uses the correct method name and syntax.

3. Final Answer:

   const stream = fs.createReadStream('data.txt'); -> Option A

4. Quick Check:

   Use createReadStream() to read files as streams [OK]

Hint: Use fs.createReadStream() to open file streams [OK]

Common Mistakes:

• Using fs.readFile() which reads whole file, not stream
• Using non-existent methods like openStream or streamFile
• Missing quotes around filename

3. Consider this Node.js code snippet:

const fs = require('fs');
let data = '';
const stream = fs.createReadStream('file.txt');
stream.on('data', chunk => { data += chunk; });
stream.on('end', () => { console.log(data.length); });

What will this code output if file.txt is 5000 bytes?

medium

A. It will print undefined

B. It will print 5000

C. It will print 0

D. It will throw an error

Solution

1. Step 1: Understand stream data event

   The 'data' event adds chunks of the file to the data string as they arrive.

2. Step 2: Check what happens on 'end'

   When the stream ends, data.length is logged, which equals the total bytes read (5000).

3. Final Answer:

   It will print 5000 -> Option B

4. Quick Check:

   Stream chunks combined length = file size [OK]

Hint: Stream 'data' events accumulate full content length [OK]

Common Mistakes:

• Assuming data is empty before 'end' event
• Expecting undefined because of async nature
• Thinking stream throws error without error handler

4. This code tries to read a file using streams but does not print anything:

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

What is the likely reason no output appears?

medium

A. Streams require a 'data' event to be removed to work.

B. The 'end' event is missing to start reading.

C. The file path is incorrect or file does not exist.

D. The stream is paused by default and needs resume() call.

Solution

1. Step 1: Check if file exists

   If the file path is wrong or file missing, stream emits error and no data event triggers.

2. Step 2: Understand stream default behavior

   Streams start flowing automatically when 'data' event is attached; no need to call resume().

3. Final Answer:

   The file path is incorrect or file does not exist. -> Option C

4. Quick Check:

   No output usually means file missing or wrong path [OK]

Hint: Check file path first if streams show no output [OK]

Common Mistakes:

• Thinking 'end' event triggers reading
• Believing streams pause by default without resume()
• Removing 'data' event to fix reading

5. You want to process a very large log file line by line without loading it fully into memory. Which approach best fits this need in Node.js?

hard

A. Use fs.createReadStream() with a line-by-line parser like readline module.

B. Use fs.open() and read fixed-size buffers manually without streams.

C. Use synchronous file reading with fs.readFileSync().

D. Use fs.readFile() to load entire file, then split lines.

Solution

1. Step 1: Identify memory-efficient reading

   Loading entire file or synchronous reading uses lots of memory and blocks event loop.

2. Step 2: Combine streams with line parsing

   Using fs.createReadStream() with readline module reads file chunk by chunk and processes lines efficiently.

3. Final Answer:

   Use fs.createReadStream() with a line-by-line parser like readline module. -> Option A

4. Quick Check:

   Streams + readline = memory-efficient line processing [OK]

Hint: Combine streams with readline for big file line processing [OK]

Common Mistakes:

• Loading entire file for big logs causes memory issues
• Using synchronous methods blocks Node.js event loop
• Reading fixed buffers manually is complex and error-prone