Reading files asynchronously with callbacks in Node.js - Mini Project: Build & Apply

Reading files asynchronously with callbacks in Node.js

📖 Scenario: You are building a simple Node.js script that reads the content of a text file asynchronously. This is useful when you want your program to keep working without waiting for the file to finish loading.

🎯 Goal: Learn how to read a file asynchronously using Node.js fs module with callbacks. You will create a script that reads a file named message.txt and prints its content inside the callback function.

📋 What You'll Learn

Use Node.js built-in fs module

Read the file message.txt asynchronously using fs.readFile

Use a callback function to handle the file content or error

Print the file content inside the callback

💡 Why This Matters

🌍 Real World

Reading files asynchronously is common in Node.js servers to avoid blocking the program while waiting for file data, improving performance and user experience.

💼 Career

Understanding asynchronous file reading with callbacks is essential for backend developers working with Node.js, enabling efficient file handling in real applications.

1

Import the fs module

Write a line to import the Node.js fs module using require and assign it to a variable called fs.

Node.js

# Import the fs module
# Your code here

Hint

Use const fs = require('fs'); to import the file system module.

2

Create a variable for the filename

Create a constant variable called filename and set it to the string 'message.txt'.

Node.js

const fs = require('fs');
# Create a variable called filename with value 'message.txt'
# Your code here

Hint

Use const filename = 'message.txt'; to store the file name.

3

Read the file asynchronously with a callback

Use fs.readFile with filename, encoding 'utf8', and a callback function with parameters err and data. Inside the callback, if err is not null, return immediately. Otherwise, log data to the console.

Node.js

const fs = require('fs');
const filename = 'message.txt';

# Use fs.readFile with filename, 'utf8', and a callback function (err, data)
# Inside callback, if err exists return, else console.log data
# Your code here

Hint

Use fs.readFile(filename, 'utf8', (err, data) => { ... }) and handle error by returning early.

4

Add error message logging inside the callback

Modify the callback function so that if err exists, it logs 'Error reading file' to the console before returning.

Node.js

const fs = require('fs');
const filename = 'message.txt';

fs.readFile(filename, 'utf8', (err, data) => {
    # If err exists, log 'Error reading file' and return
    # Your code here
    console.log(data);
});

Hint

Inside the callback, check if (err) { console.log('Error reading file'); return; }.

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