Callback pattern and callback hell in Node.js - Mini Project: Build & Apply

Understanding Callback Pattern and Callback Hell in Node.js

📖 Scenario: You are building a simple Node.js program that simulates fetching user data, then fetching the user's posts, and finally fetching comments on those posts. Each step uses a callback function to handle the asynchronous operation.This project will help you understand how callbacks work and how nested callbacks can lead to callback hell.

🎯 Goal: Create a series of nested callback functions to simulate asynchronous data fetching in Node.js. You will write code that first fetches a user, then fetches posts for that user, and finally fetches comments for those posts, all using callbacks.

📋 What You'll Learn

Create a function called getUser that takes a userId and a callback, then calls the callback with user data.

Create a function called getPosts that takes a userId and a callback, then calls the callback with posts data.

Create a function called getComments that takes a postId and a callback, then calls the callback with comments data.

Use nested callbacks to fetch user, then posts, then comments in sequence.

Observe the nested structure that leads to callback hell.

💡 Why This Matters

🌍 Real World

Many Node.js applications use callbacks to handle asynchronous operations like reading files, making network requests, or querying databases.

💼 Career

Understanding callbacks and callback hell is essential for Node.js developers to write clean, maintainable asynchronous code and to transition to modern async patterns.

1

Create the getUser function

Write a function called getUser that takes two parameters: userId and callback. Inside the function, simulate an asynchronous operation using setTimeout that after 100ms calls the callback with an object { id: userId, name: 'Alice' }.

Node.js

# Your code here
// Define getUser function with userId and callback parameters
// Use setTimeout to simulate async call
// After 100ms, call callback with user object { id: userId, name: 'Alice' }

Need a hint?

Use setTimeout to simulate delay. Call callback inside the timeout with the user object.

2

Create the getPosts function

Add a function called getPosts that takes userId and callback as parameters. Use setTimeout to simulate an async call that after 100ms calls callback with an array of posts: [{ id: 1, title: 'Post 1' }, { id: 2, title: 'Post 2' }].

Node.js

function getUser(userId, callback) {
  setTimeout(() => {
    callback({ id: userId, name: 'Alice' });
  }, 100);
}

// Your code here
// Define getPosts function with userId and callback
// Use setTimeout to simulate async call
// After 100ms, call callback with posts array [{ id: 1, title: 'Post 1' }, { id: 2, title: 'Post 2' }]

Need a hint?

Similar to getUser, use setTimeout and call callback with the posts array.

3

Create the getComments function

Add a function called getComments that takes postId and callback as parameters. Use setTimeout to simulate an async call that after 100ms calls callback with an array of comments: [{ id: 101, text: 'Great post!' }, { id: 102, text: 'Thanks for sharing' }].

Node.js

function getUser(userId, callback) {
  setTimeout(() => {
    callback({ id: userId, name: 'Alice' });
  }, 100);
}

function getPosts(userId, callback) {
  setTimeout(() => {
    callback([{ id: 1, title: 'Post 1' }, { id: 2, title: 'Post 2' }]);
  }, 100);
}

// Your code here
// Define getComments function with postId and callback
// Use setTimeout to simulate async call
// After 100ms, call callback with comments array [{ id: 101, text: 'Great post!' }, { id: 102, text: 'Thanks for sharing' }]

Need a hint?

Follow the same pattern as previous functions. Use setTimeout and call callback with the comments array.

4

Use nested callbacks to fetch user, posts, and comments

Write code that calls getUser with userId 1 and a callback that receives the user. Inside that callback, call getPosts with the user's id and a callback that receives posts. Inside that callback, call getComments with the first post's id and a callback that receives comments. This nesting shows callback hell.

Node.js

function getUser(userId, callback) {
  setTimeout(() => {
    callback({ id: userId, name: 'Alice' });
  }, 100);
}

function getPosts(userId, callback) {
  setTimeout(() => {
    callback([{ id: 1, title: 'Post 1' }, { id: 2, title: 'Post 2' }]);
  }, 100);
}

function getComments(postId, callback) {
  setTimeout(() => {
    callback([{ id: 101, text: 'Great post!' }, { id: 102, text: 'Thanks for sharing' }]);
  }, 100);
}

// Your code here
// Call getUser with userId 1 and a callback
// Inside that callback, call getPosts with user.id and a callback
// Inside that callback, call getComments with first post id and a callback

Need a hint?

Each callback is nested inside the previous one to show how callbacks can become deeply nested.