Callbacks in JavaScript
and the Callback Hell

Understanding Callbacks in JavaScript

JavaScript is single-threaded and often performs asynchronous operations like API calls, timers, or file reading. To handle such operations without blocking the main thread, callbacks are used.

What is a Callback?

A callback is a function passed as an argument to another function, which is then invoked inside that function after some operation is complete.

Example: Basic Callback Function

function greetUser(name, callback) {
  console.log("Hello " + name);
  callback();
}

function sayBye() {
  console.log("Goodbye!");
}

greetUser("Alice", sayBye);

Hello Alice
Goodbye!

Why are Callbacks Important?

JavaScript executes code line by line, but asynchronous operations (like network requests) don’t complete instantly. Callbacks ensure that a task runs only after the previous one finishes.

Example: Simulating Asynchronous Execution

function fetchData(callback) {
  setTimeout(() => {
    console.log("Data fetched from server.");
    callback();
  }, 2000);
}

function processData() {
  console.log("Processing data...");
}

fetchData(processData);

Data fetched from server.
Processing data...

What if we have multiple steps depending on each other?

Let’s simulate a real-world example: logging in, fetching user profile, then fetching posts.

Example: Nested Callbacks

function loginUser(callback) {
  setTimeout(() => {
    console.log("User logged in");
    callback();
  }, 1000);
}

function fetchProfile(callback) {
  setTimeout(() => {
    console.log("User profile fetched");
    callback();
  }, 1000);
}

function fetchPosts() {
  setTimeout(() => {
    console.log("User posts fetched");
  }, 1000);
}

loginUser(() => {
  fetchProfile(() => {
    fetchPosts();
  });
});

User logged in
User profile fetched
User posts fetched

What is Callback Hell?

When multiple asynchronous operations are nested within each other in this way, it creates deeply nested code that is hard to read, debug, and maintain. This is known as Callback Hell or the “Pyramid of Doom”.

Callback hell makes the code look like this:

task1(() => {
  task2(() => {
    task3(() => {
      task4(() => {
        // and so on...
      });
    });
  });
});

Question: Why not just call functions sequentially?

Answer: Because functions like setTimeout or fetch are asynchronous. If you don’t use callbacks (or promises), the next function might execute before the previous one finishes.

How to Avoid Callback Hell?

Solutions include:

• Splitting functions into smaller named functions
• Using Promises
• Using async/await

We will explore Promises and async/await in upcoming modules to resolve this issue effectively.

Summary

• Callbacks are functions passed to another function to execute later.
• They are essential in handling asynchronous code in JavaScript.
• Nested callbacks lead to callback hell — hard-to-maintain code structure.
• Modern JavaScript uses Promises and async/await for cleaner asynchronous code.