Reading files asynchronously with callbacks in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Node.js asynchronous file read?

Consider the following code snippet that reads a file asynchronously using callbacks. What will be printed to the console?

Node.js

import { readFile } from 'node:fs';

readFile('example.txt', 'utf8', (err, data) => {
  if (err) {
    console.log('Error:', err.message);
  } else {
    console.log('File content:', data);
  }
});

console.log('Read request sent');

A Error: ENOENT: no such file or directory, open 'example.txt'\nRead request sent

B File content: (contents of example.txt)\nRead request sent

C Read request sent\nFile content: (contents of example.txt)

D Read request sent

💡 Hint

Remember that readFile is asynchronous and the callback runs after the main thread continues.

The console.log('Read request sent') runs immediately after calling readFile, before the file is read. The callback runs later and prints the file content or error.

❓ component_behavior

intermediate

What happens if the callback is missing in readFile?

What will happen if you call readFile without providing a callback function?

Node.js

import { readFile } from 'node:fs';

readFile('example.txt', 'utf8');

A A TypeError is thrown because callback is required.

B The program crashes with an unhandled exception.

C Nothing happens; the file is not read.

D The file is read and data is returned synchronously.

💡 Hint

Check the Node.js documentation for readFile function signature.

The readFile function requires a callback to handle the result asynchronously. Omitting it causes a TypeError.

🔧 Debug

advanced

Why does this callback not print the file content?

This code tries to read a file and print its content but only prints 'Read request sent'. What is the issue?

Node.js

import { readFile } from 'node:fs';

readFile('example.txt', 'utf8', (err, data) => {
  if (err) {
    console.error(err);
  }
});

console.log('Read request sent');

A The callback does not print the data when there is no error.

B The file path is incorrect causing silent failure.

C The encoding option 'utf8' is invalid causing no data.

D The console.log outside the callback blocks the callback from running.

💡 Hint

Look at what the callback does when there is no error.

The callback only logs errors but does not print the file content when reading succeeds.

📝 Syntax

advanced

Which option correctly reads a file asynchronously with a callback?

Select the code snippet that correctly reads 'data.txt' asynchronously and logs its content or error.

A readFile('data.txt', (data, err) => { if (err) throw err; console.log(data); });

B readFile('data.txt', (err, data) => { if (err) throw err; console.log(data); });

C readFile('data.txt', 'utf8', (data, err) => { if (err) throw err; console.log(data); });

D readFile('data.txt', 'utf8', (err, data) => { if (err) throw err; console.log(data); });

💡 Hint

Check the order of parameters in the callback and the encoding argument.

The callback parameters are (err, data). Option D correctly passes encoding and uses correct parameter order.

❓ state_output

expert

What is the value of 'result' after this asynchronous readFile call?

Given this code, what will be the value of 'result' after execution?

Node.js

import { readFile } from 'node:fs';

let result = '';

readFile('file.txt', 'utf8', (err, data) => {
  if (!err) {
    result = data;
  }
});

console.log(result);

A Throws a ReferenceError.

B An empty string.

C undefined.

D The content of 'file.txt' as a string.

💡 Hint

Remember that readFile is asynchronous and console.log runs before the callback.

The console.log runs immediately before the callback updates 'result', so it prints the initial empty string.

Practice

1. What is the main purpose of using fs.readFile with a callback in Node.js?

easy

A. To delete a file from the system

B. To write data to a file synchronously

C. To create a new directory

D. To read a file asynchronously without blocking the program

Solution

1. Step 1: Understand fs.readFile role

   fs.readFile reads files without stopping other code from running.

2. Step 2: Recognize asynchronous behavior

   Using a callback means the program continues while the file is read, improving speed.

3. Final Answer:

   To read a file asynchronously without blocking the program -> Option D

4. Quick Check:

   Asynchronous reading = non-blocking file read [OK]

Hint: Remember: async means non-blocking, callback runs after reading [OK]

Common Mistakes:

• Confusing reading with writing files
• Thinking fs.readFile is synchronous
• Ignoring the callback function

2. Which of the following is the correct syntax to read a file named data.txt asynchronously using fs.readFile with a callback?

easy

A. fs.readFile('data.txt');

B. fs.readFile('data.txt', data => { console.log(data); });

C. fs.readFile('data.txt', (err, data) => { if (err) throw err; console.log(data); });

D. fs.readFile('data.txt', (data, err) => { if (err) throw err; console.log(data); });

Solution

1. Step 1: Check callback parameters order

   The callback receives err first, then data.

2. Step 2: Verify error handling and usage

   fs.readFile('data.txt', (err, data) => { if (err) throw err; console.log(data); }); correctly checks for error and logs data inside the callback.

3. Final Answer:

   fs.readFile('data.txt', (err, data) => { if (err) throw err; console.log(data); }); -> Option C

4. Quick Check:

   Callback params = (err, data) [OK]

Hint: Callback always has error first, then data [OK]

Common Mistakes:

• Swapping error and data parameters
• Omitting the callback function
• Not handling errors inside callback

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

const fs = require('fs');
fs.readFile('example.txt', (err, data) => {
  if (err) {
    console.log('Error reading file');
  } else {
    console.log(data.toString());
  }
});

medium

A. Error reading file

B. Hello World

C. [object Object]

D. undefined

Solution

1. Step 1: Understand callback behavior

   If no error, data contains file content as a Buffer.

2. Step 2: Convert Buffer to string

   data.toString() converts Buffer to readable text, so it prints "Hello World".

3. Final Answer:

   Hello World -> Option B

4. Quick Check:

   Buffer.toString() = file text [OK]

Hint: Use toString() to read file content as text [OK]

Common Mistakes:

• Printing Buffer object directly without conversion
• Ignoring error handling
• Expecting synchronous output

4. Identify the error in this code snippet that reads a file asynchronously:

const fs = require('fs');
fs.readFile('notes.txt', (data, err) => {
  if (err) {
    console.error('Failed to read file');
  } else {
    console.log(data.toString());
  }
});

medium

A. The callback parameters are reversed; error should be first

B. Missing encoding option in readFile

C. Using console.error instead of console.log

D. File path should be absolute

Solution

1. Step 1: Check callback parameter order

   The callback must have err as first parameter, then data.

2. Step 2: Understand impact of reversed parameters

   Reversing causes data to receive error and err to receive data, breaking error check.

3. Final Answer:

   The callback parameters are reversed; error should be first -> Option A

4. Quick Check:

   Callback params order = (err, data) [OK]

Hint: Error always comes first in callback parameters [OK]

Common Mistakes:

• Swapping error and data parameters
• Not handling errors properly
• Assuming encoding is mandatory

5. You want to read multiple files asynchronously and log their contents in order: file1.txt, file2.txt, and file3.txt. Which approach correctly ensures the files are read and logged in sequence using callbacks?

hard

A. Call fs.readFile for each file inside the previous file's callback

B. Call fs.readFile for all files at once without nesting callbacks

C. Use synchronous fs.readFileSync for all files

D. Use fs.readFile with promises instead of callbacks

Solution

1. Step 1: Understand asynchronous reading order

   Calling fs.readFile without nesting may log files out of order.

2. Step 2: Use nested callbacks to enforce sequence

   Reading each file inside the previous file's callback ensures order.

3. Final Answer:

   Call fs.readFile for each file inside the previous file's callback -> Option A

4. Quick Check:

   Nested callbacks = ordered async reads [OK]

Hint: Nest callbacks to keep async file reads in order [OK]

Common Mistakes:

• Calling all reads at once expecting order
• Using synchronous reads in async code
• Confusing promises with callbacks