Callback pattern and callback hell in Node.js - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a callback function in Node.js?

A callback function is a function passed as an argument to another function, which is then called after some operation completes. It helps handle asynchronous tasks.

beginner

Explain the term 'callback hell'.

Callback hell happens when many callbacks are nested inside each other, making code hard to read and maintain, like a pyramid or 'arrow' shape.

intermediate

Why does callback hell make code difficult to maintain?

Because deeply nested callbacks create complex, hard-to-follow code flow, making debugging and updates confusing and error-prone.

intermediate

How can you avoid callback hell in Node.js?

You can avoid callback hell by using techniques like named functions, Promises, async/await, or modularizing code into smaller functions.

beginner

Show a simple example of a callback function in Node.js.

Example:
function greet(name, callback) {
  console.log('Hello ' + name);
  callback();
}
greet('Alice', () => {
  console.log('Greeting done');
});

What is the main purpose of a callback function in Node.js?

A To stop the program execution

B To handle asynchronous operations after they complete

C To create global variables

D To style the webpage

Callbacks let you run code after an asynchronous task finishes, like reading a file or fetching data.

What does 'callback hell' usually look like in code?

A Using only synchronous code

B A single function with no callbacks

C Functions without any parameters

D Many nested callback functions inside each other

Callback hell is when callbacks are nested deeply, making code hard to read.

Which of these is NOT a way to avoid callback hell?

A Using Promises

B Using async/await

C Writing all code in one big callback

D Breaking code into smaller functions

Writing all code in one big callback causes callback hell, not avoids it.

In the callback pattern, when is the callback function called?

A After the main task finishes

B Before the main task starts

C Only if an error occurs

D Randomly during execution

The callback runs after the main asynchronous task completes.

What is a common problem caused by callback hell?

A Code becomes hard to read and debug

B Code runs faster

C More memory is freed

D Functions stop working

Callback hell makes code complex and difficult to maintain.

Describe what a callback function is and why it is used in Node.js.

Think about how Node.js waits for tasks like reading files.

Explain what callback hell is and list two ways to avoid it.

Imagine a pyramid of functions inside functions.

Practice

1. What is the main purpose of a callback function in Node.js?

easy

A. To run code after an asynchronous action finishes

B. To stop the program execution immediately

C. To create a new thread for parallel processing

D. To convert synchronous code into asynchronous code automatically

Solution

1. Step 1: Understand asynchronous actions in Node.js

   Node.js uses callbacks to handle tasks that take time, like reading files or fetching data, without stopping the program.

2. Step 2: Identify the role of the callback

   The callback function runs after the task finishes, allowing the program to continue smoothly.

3. Final Answer:

   To run code after an asynchronous action finishes -> Option A

4. Quick Check:

   Callback = run after async task [OK]

Hint: Callbacks run code after tasks finish [OK]

Common Mistakes:

• Thinking callbacks stop program execution
• Confusing callbacks with threads
• Assuming callbacks convert sync to async automatically

2. Which of the following is the correct function declaration syntax to define a callback function in Node.js?

easy

A. function callback { console.log('Done'); }

B. callback => { console.log('Done'); }

C. function callback() { console.log('Done'); }

D. callback() => { console.log('Done'); }

Solution

1. Step 1: Review function declaration syntax

   In JavaScript, a function is declared with the keyword 'function' followed by parentheses and curly braces.

2. Step 2: Check each option for syntax correctness

   function callback() { console.log('Done'); } uses correct syntax. callback => { console.log('Done'); } is an arrow function expression, not a function declaration. function callback { console.log('Done'); } misses parentheses after function name. callback() => { console.log('Done'); } mixes arrow function and parentheses incorrectly.

3. Final Answer:

   function callback() { console.log('Done'); } -> Option C

4. Quick Check:

   Correct function syntax = function callback() { console.log('Done'); } [OK]

Hint: Function syntax: function name() { } [OK]

Common Mistakes:

• Omitting parentheses in function declaration
• Mixing arrow function syntax incorrectly
• Missing curly braces for function body

3. What will be the output of the following code?

function first(callback) {
  setTimeout(() => {
    console.log('First');
    callback();
  }, 100);
}

function second() {
  console.log('Second');
}

first(second);

medium

A. First\nSecond

B. Second\nFirst

C. First

D. Second

Solution

1. Step 1: Understand setTimeout behavior

   setTimeout delays the function inside it by 100 milliseconds, then runs the callback.

2. Step 2: Trace the code execution order

   first() calls setTimeout, which waits 100ms, then logs 'First' and calls second(). So 'First' prints first, then 'Second'.

3. Final Answer:

   First\nSecond -> Option A

4. Quick Check:

   Callback runs after delay = 'First' then 'Second' [OK]

Hint: setTimeout delays code, callback runs after delay [OK]

Common Mistakes:

• Assuming callback runs immediately
• Confusing order of console logs
• Ignoring asynchronous delay

4. Identify the problem in this nested callback code and how to fix it:

readFile('file1.txt', function(err, data1) {
  if (err) throw err;
  readFile('file2.txt', function(err, data2) {
    if (err) throw err;
    readFile('file3.txt', function(err, data3) {
      if (err) throw err;
      console.log(data1, data2, data3);
    });
  });
});

medium

A. Use synchronous readFileSync to avoid callbacks

B. This is callback hell; fix by using Promises or async/await

C. Syntax error: missing semicolons after callbacks

D. No problem; this is the best way to read files sequentially

Solution

1. Step 1: Recognize nested callbacks cause callback hell

   Multiple nested callbacks make code hard to read and maintain, known as callback hell.

2. Step 2: Suggest modern alternatives

   Using Promises or async/await flattens the code, making it cleaner and easier to follow.

3. Final Answer:

   This is callback hell; fix by using Promises or async/await -> Option B

4. Quick Check:

   Nested callbacks = callback hell, use Promises [OK]

Hint: Nested callbacks = callback hell; use Promises [OK]

Common Mistakes:

• Ignoring readability problems
• Thinking semicolons fix callback hell
• Using synchronous calls in async code

5. You have three asynchronous tasks that depend on each other in sequence. Which approach best avoids callback hell while keeping the tasks in order?

hard

A. Use nested callbacks for each task

B. Use setTimeout to delay each task manually

C. Run all tasks in parallel without waiting

D. Use Promises chaining or async/await syntax

Solution

1. Step 1: Understand the problem of callback hell

   Nested callbacks make code messy and hard to maintain when tasks depend on each other.

2. Step 2: Identify better patterns for sequencing async tasks

   Promises chaining or async/await syntax keep code flat and readable while preserving order.

3. Final Answer:

   Use Promises chaining or async/await syntax -> Option D

4. Quick Check:

   Promises/async await = clean sequential async code [OK]

Hint: Use Promises or async/await for clean async flow [OK]

Common Mistakes:

• Using nested callbacks causing callback hell
• Running tasks in parallel when order matters
• Using setTimeout for sequencing tasks