Reading files asynchronously with callbacks in Node.js - Step-by-Step Execution

Concept Flow - Reading files asynchronously with callbacks

Start

↓

Call fs.readFile

↓

Node.js reads file in background

↓

File read complete?

No→Wait

Yes↓

Invoke callback with error or data

↓

Callback processes data or error

↓

End

This flow shows how Node.js starts reading a file, waits in the background, then calls your callback with the result.

Execution Sample

Node.js

const fs = require('fs');
fs.readFile('hello.txt', 'utf8', (err, data) => {
  if (err) {
    console.error('Error:', err);
  } else {
    console.log('File content:', data);
  }
});

Reads 'hello.txt' asynchronously and prints its content or error using a callback.

Execution Table

Step	Action	Evaluation	Result
1	Call fs.readFile with filename, encoding, callback	Starts async file read	File read started, Node.js continues other tasks
2	Node.js reads file in background	File reading in progress	No output yet, waiting
3	File read completes successfully	err is null, data contains file text	Callback invoked with data
4	Callback runs: if err null?	Yes, err is null	Prints 'File content: <file text>'
5	Program continues running	No blocking happened	Ready for next tasks
6	If file read failed	err contains error	Callback prints 'Error: <error message>'

💡 Execution stops after callback runs with either error or data, no blocking occurs.

Variable Tracker

Variable	Start	After Step 1	After Step 3	After Step 4	Final
err	undefined	undefined	null or Error object	null or Error object	null or Error object
data	undefined	undefined	file content string or undefined	file content string or undefined	file content string or undefined

Key Moments - 3 Insights

Why doesn't the program wait for the file to finish reading before moving on?

Because fs.readFile is asynchronous, it starts reading and immediately returns control. The callback runs later when reading finishes, as shown in execution_table step 1 and 2.

How do we know if reading the file succeeded or failed inside the callback?

The callback receives 'err' and 'data'. If 'err' is null, reading succeeded (step 3). If 'err' has a value, reading failed (step 6).

What happens if we try to use 'data' outside the callback right after calling fs.readFile?

At that moment, 'data' is still undefined because reading is not finished yet. You must use 'data' inside the callback to access the file content.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'err' at step 3 when the file is read successfully?

A undefined

B Error object

C null

D File content string

💡 Hint

Check the 'err' variable value in variable_tracker after step 3.

At which step does the callback function get called?

A Step 3

B Step 5

C Step 1

D Step 6

💡 Hint

Look at execution_table where the callback is invoked with data or error.

If the file does not exist, what will the callback print?

A Nothing, callback is not called

B 'Error: <error message>'

C 'File content: <file text>'

D An empty string

💡 Hint

Refer to execution_table step 6 and key_moments about error handling.

Concept Snapshot

fs.readFile(filename, encoding, callback)
- Starts reading file asynchronously
- Callback(err, data) runs after reading
- err is null if success, else error
- Use data only inside callback
- Program continues without waiting

Full Transcript

This visual execution shows how Node.js reads files asynchronously using fs.readFile. When you call fs.readFile, Node.js starts reading the file in the background and immediately continues running other code. Once the file is fully read or an error occurs, Node.js calls your callback function with two arguments: an error object (or null if no error) and the file data. You check inside the callback if err is null to know if reading succeeded. You must use the file data only inside the callback because outside it is not yet available. This approach avoids blocking your program while waiting for file operations.

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