Error-first callback convention in Node.js - Step-by-Step Execution

Concept Flow - Error-first callback convention

Function called

↓

Operation starts

↓

Operation finishes

↓

Check for error

↓

Call callback

This flow shows how a function performs an operation, then calls a callback with an error first if any, or with the result if no error.

Execution Sample

Node.js

function readFile(callback) {
  let error = null;
  let data = 'file content';
  callback(error, data);
}

readFile((err, content) => {
  if (err) console.error(err);
  else console.log(content);
});

This code simulates reading a file and calls a callback with error first, then data.

Execution Table

Step	Action	Error Value	Data Value	Callback Called With
1	Function readFile called	undefined	undefined	No
2	Operation starts (simulate reading)	null	undefined	No
3	Operation finishes	null	'file content'	No
4	Callback called with error and data	null	'file content'	callback(null, 'file content')
5	Callback executes: err check	null	'file content'	No error branch taken, logs 'file content'

💡 Callback called once with error=null and data='file content', execution ends.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
error	undefined	null	null	null	null
data	undefined	undefined	'file content'	'file content'	'file content'

Key Moments - 2 Insights

Why is the error argument always first in the callback?

Because the convention is to check for errors first before processing data, as shown in step 4 and 5 of the execution_table.

What happens if there is an error?

The callback is called with the error as the first argument and usually no data, so the error branch is taken immediately, as the flow diagram shows.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'error' when the callback is called?

A 'file content'

B null

C undefined

D An Error object

💡 Hint

Check the 'Error Value' column at step 4 in the execution_table.

At which step does the callback get called with the data?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Callback Called With' column in the execution_table.

If an error occurred, how would the callback call change in the execution_table?

A callback(error, null)

B callback(data, error)

C callback(null, data)

D callback(data)

💡 Hint

Refer to the concept_flow where error is passed first if present.

Concept Snapshot

Error-first callback convention:
- Callback signature: callback(error, result)
- Always check error first
- If error exists, handle it immediately
- If no error, process the result
- Keeps async code clear and consistent

Full Transcript

In Node.js, many functions use the error-first callback pattern. This means the callback function receives an error as its first argument and the result as the second. When the function finishes its operation, it calls the callback. If there was an error, it passes that error first and usually no result. If no error occurred, it passes null for the error and the actual result as the second argument. This pattern helps developers quickly check for errors before using the data. The example code simulates reading a file and calls the callback with null error and file content. The execution table shows each step, including when the callback is called and how variables change. Understanding this flow helps avoid confusion when working with asynchronous Node.js code.

Practice

1. What is the main purpose of the error-first callback convention in Node.js?

easy

A. To avoid using callbacks and use promises instead

B. To pass the result as the first argument and error as the second

C. To handle errors only after all callbacks have finished

D. To always pass the error as the first argument to the callback function

Solution

1. Step 1: Understand the callback argument order

   The error-first callback convention means the first argument is always the error if any occurred.

2. Step 2: Recognize the purpose of this order

   This helps developers check for errors before processing results, making code safer and clearer.

3. Final Answer:

   To always pass the error as the first argument to the callback function -> Option D

4. Quick Check:

   Error is first argument [OK]

Hint: Error always comes first in callbacks [OK]

Common Mistakes:

• Thinking result comes before error
• Confusing error-first with promise usage
• Ignoring error handling in callbacks

2. Which of the following is the correct syntax for an error-first callback function in Node.js?

easy

A. function callback(error, result) { ... }

B. function callback(result, error) { ... }

C. function callback() { ... }

D. function callback(result) { ... }

Solution

1. Step 1: Identify the correct parameter order

   The error-first callback convention requires the first parameter to be error, second to be result.

2. Step 2: Match the syntax

   Only the function with parameters (error, result) follows this convention correctly.

3. Final Answer:

   function callback(error, result) { ... } -> Option A

4. Quick Check:

   Callback params: error first, result second [OK]

Hint: Error is first parameter in callback functions [OK]

Common Mistakes:

• Swapping error and result parameters
• Omitting error parameter
• Using only one parameter for result

3. Consider the following code snippet:

function readFile(callback) {
  setTimeout(() => {
    callback(null, 'file content');
  }, 100);
}

readFile((err, data) => {
  if (err) {
    console.log('Error:', err);
  } else {
    console.log('Data:', data);
  }
});

What will be printed to the console?

medium

A. Error: null

B. Data: file content

C. Error: file content

D. Nothing will be printed

Solution

1. Step 1: Analyze the callback invocation

   The callback is called with null as error and 'file content' as data after 100ms.

2. Step 2: Check the callback logic

   Since err is null (no error), the else branch runs and logs 'Data: file content'.

3. Final Answer:

   Data: file content -> Option B

4. Quick Check:

   Null error means success, so data logs [OK]

Hint: Null error means no error, print data [OK]

Common Mistakes:

• Printing error when error is null
• Confusing error and data values
• Expecting no output due to async

4. Identify the error in this code using error-first callback convention:

function getData(callback) {
  const error = null;
  const result = 'Success';
  callback(result, error);
}

getData((err, data) => {
  if (err) {
    console.log('Error:', err);
  } else {
    console.log('Data:', data);
  }
});

medium

A. No error handling is needed here

B. The callback function is missing

C. The callback arguments are reversed; error should be first

D. The error variable should be a string, not null

Solution

1. Step 1: Check callback argument order

   The callback is called with (result, error) but error-first convention requires (error, result).

2. Step 2: Understand impact of reversed arguments

   This reversal causes the callback to treat 'Success' as error and null as data, breaking logic.

3. Final Answer:

   The callback arguments are reversed; error should be first -> Option C

4. Quick Check:

   Callback args must be (error, result) [OK]

Hint: Error must be first argument in callback calls [OK]

Common Mistakes:

• Passing result before error
• Ignoring argument order in callbacks
• Assuming error can be second argument

5. You have a function that reads user data asynchronously and uses an error-first callback:

function fetchUser(id, callback) {
  if (id <= 0) {
    callback(new Error('Invalid ID'), null);
  } else {
    setTimeout(() => {
      callback(null, { id, name: 'Alice' });
    }, 50);
  }
}

How should you call fetchUser to correctly handle errors and print the user's name or the error message?

hard

A. fetchUser(1, (err, user) => { if (err) console.log(err.message); else console.log(user.name); });

B. fetchUser(1, (err, user) => { if (user) console.log(user.name); else console.log(err.message); });

C. fetchUser(1, (user, err) => { if (err) console.log(err.message); else console.log(user.name); });

D. fetchUser(1, (err, user) => { console.log(user.name); });

Solution

1. Step 1: Check callback parameter order and error handling

   The callback parameters must be (err, user). We check if err exists first to handle errors.

2. Step 2: Verify correct conditional logic

   If err exists, print err.message; otherwise, print user.name. fetchUser(1, (err, user) => { if (err) console.log(err.message); else console.log(user.name); }); follows this correctly.

3. Final Answer:

   fetchUser(1, (err, user) => { if (err) console.log(err.message); else console.log(user.name); }); -> Option A

4. Quick Check:

   Check error first, then use user [OK]

Hint: Always check error before using result in callback [OK]

Common Mistakes:

• Swapping error and user parameters
• Not checking error before accessing user
• Ignoring error handling completely