Understanding Callbacks in Node.js – The Ultimate Guide

NodeJs

"Node.js is like a magical kitchen for JavaScript—originally, it could only cook in the browser, but now it can build backends, manage servers, and even make coffee... if there's an npm package for it!"

 

Have you ever ordered pizza and had to wait until it was ready?
Do you just stand there and stare at the oven? Of course not!

Instead, you continue doing other things—maybe watch TV or scroll through memes—until the pizza shop calls you when it’s ready.

This is exactly how callbacks work in Node.js!

• In this guide, we’ll cover:
• What is a callback function?
• Why does Node.js use callbacks?
• How to write and use callbacks in real-life scenarios.
• How to avoid callback hell.

Let’s dive in!

 

1️What is a Callback Function?

A callback function is simply a function that is passed as an argument to another function and gets executed later.

Think of it like leaving your phone number at a restaurant so they can call you when your food is ready!

Example of a Simple Callback

function greet(name, callback) {
    console.log(`Hello, ${name}!`);
    callback();
}

function sayGoodbye() {
    console.log("Goodbye! See you soon! ");
}

greet("Alice", sayGoodbye);

Output:

Hello, Alice!
Goodbye! See you soon! 

Explanation:

1. greet() takes a callback function.
2. It executes the callback (sayGoodbye()) after greeting Alice.

 

2️Why Does Node.js Use Callbacks?

Node.js is asynchronous and non-blocking. Instead of waiting for tasks to complete, it uses callbacks to handle operations in the background.

Example: Reading a file

const fs = require('fs');

fs.readFile('example.txt', 'utf8', function (err, data) {
    if (err) throw err;
    console.log(data);
});

console.log("Reading file... Please wait!");

Output (assuming example.txt contains "Hello, World!")

Reading file... Please wait!
Hello, World!

Explanation:

• Node.js doesn’t wait for fs.readFile() to finish.
• Instead, it moves on to the next task and executes the callback once the file is read.

This makes Node.js super fast and efficient!

 

3️Writing Your Own Callback Functions

Let’s build a simple order system using callbacks!

function orderPizza(flavor, callback) {
    console.log(`Ordering a ${flavor} pizza... `);
    
    setTimeout(() => {
        console.log(`${flavor} pizza is ready!`);
        callback();
    }, 3000); // Simulates a 3-second wait
}

function eatPizza() {
    console.log("Eating the pizza... Yum! ");
}

orderPizza("Pepperoni", eatPizza);

Output:

Ordering a Pepperoni pizza... 
(Pizza is being prepared...)
Pepperoni pizza is ready!
Eating the pizza... Yum! 

Explanation:

• The pizza takes time to be ready (setTimeout() simulates this).
• Instead of waiting, Node.js continues executing other tasks.
• When the pizza is ready, it calls the eatPizza function.

 

4️Callback Hell – The Nightmare of Nested Callbacks

While callbacks are great, too many nested callbacks can become messy and unreadable.

Example of Callback Hell:

getUser(1, function(user) {
    getOrders(user.id, function(orders) {
        getOrderDetails(orders[0], function(details) {
            getShippingInfo(details, function(shipping) {
                console.log("Shipping Info:", shipping);
            });
        });
    });
});

Looks scary, right?

How to Avoid Callback Hell?

Solution 1: Use Named Functions

function getUser(userId, callback) {
    // Simulate getting user data
    setTimeout(() => callback({ id: userId, name: "Alice" }), 1000);
}

function getOrders(userId, callback) {
    setTimeout(() => callback(["Order1", "Order2"]), 1000);
}

function getOrderDetails(order, callback) {
    setTimeout(() => callback({ order, details: "Some details" }), 1000);
}

function getShippingInfo(details, callback) {
    setTimeout(() => callback({ details, status: "Shipped" }), 1000);
}

// Clean structure
getUser(1, function(user) {
    getOrders(user.id, handleOrders);
});

function handleOrders(orders) {
    getOrderDetails(orders[0], handleOrderDetails);
}

function handleOrderDetails(details) {
    getShippingInfo(details, function(shipping) {
        console.log("Shipping Info:", shipping);
    });
}

Breaking functions into smaller ones makes code cleaner!

Solution 2: Use Promises (Better than Callbacks!)

Instead of callbacks, use Promises:

function getUser(userId) {
    return new Promise(resolve => {
        setTimeout(() => resolve({ id: userId, name: "Alice" }), 1000);
    });
}

function getOrders(userId) {
    return new Promise(resolve => {
        setTimeout(() => resolve(["Order1", "Order2"]), 1000);
    });
}

function getOrderDetails(order) {
    return new Promise(resolve => {
        setTimeout(() => resolve({ order, details: "Some details" }), 1000);
    });
}

function getShippingInfo(details) {
    return new Promise(resolve => {
        setTimeout(() => resolve({ details, status: "Shipped" }), 1000);
    });
}

// Using Promises
getUser(1)
    .then(user => getOrders(user.id))
    .then(orders => getOrderDetails(orders[0]))
    .then(details => getShippingInfo(details))
    .then(shipping => console.log("Shipping Info:", shipping));

Promises make the code more readable!

Solution 3: Use Async/Await (The Best Solution!)

With async/await, callbacks become simple and clean:

async function fetchData() {
    let user = await getUser(1);
    let orders = await getOrders(user.id);
    let details = await getOrderDetails(orders[0]);
    let shipping = await getShippingInfo(details);

    console.log("Shipping Info:", shipping);
}

fetchData();

Async/Await makes code look like normal synchronous code!

 

Conclusion

Now you’re a callback pro!

• You understand what callbacks are.
• You can write asynchronous functions using callbacks.
• You know how to avoid callback hell using Promises and Async/Await.

Happy coding!