# Async Code in Node.js: Callbacks and Promises

If you are learning Node.js, you already know that it is very fast. One of the main reasons it is so fast is that it never waits around. If Node.js needs to do something slow, like reading a large file or downloading data from the internet, it starts the job in the background and immediately moves on to the next line of code.

This is called **Asynchronous (Async) Code**.

But this creates a big question: If Node.js moves on to other things, how does it know when that slow background job is finally finished? Today, we are going to look at the two main ways Node.js solves this problem: **Callbacks** and **Promises**.

## **Why Async Code Exists in Node.js**

In a traditional "Synchronous" world, code execution is a line of people waiting for a single door. If the person at the front stops to tie their shoes, the whole line stops.

Node.js is **Single-Threaded**. If you perform a "Heavy" task (like reading a 2GB file) synchronously, your entire server freezes. No other users can log in, and no other buttons will work until that file is finished.

Async code allows Node to start a task and move on to the next one immediately, coming back only when the task is finished.

## **The Old Way: Callbacks**

For a long time, the only way to handle async code in Node.js was by using **Callbacks**.

A callback is just a normal function that you pass into another function as an argument. You are basically saying to Node.js: *"Hey, go read this file. When you are finished, run this callback function to let me know."*

Let's look at a simple scenario using the built-in file system (`fs`) tool:

```javascript
const fs = require('fs');

console.log("1. Starting the program...");

// We pass a callback function as the second argument
fs.readFile('my-document.txt', 'utf8', function(error, data) {
    if (error) {
        console.log("Something went wrong!");
    } else {
        console.log("3. The file is ready! Here is the data:", data);
    }
});

console.log("2. Moving on to other tasks...");
```

**Notice the order of the numbers!** It prints 1, then 2, and finally 3 when the file is fully read. The callback function acts like an alarm clock, waking Node.js up to say the job is done.

## **The Problem: Callback Hell**

Callbacks work fine for simple tasks. But what happens if you need to do a bunch of things in a specific order?

Imagine you need to:

1.  Read a file.
    
2.  Search that file for a username.
    
3.  Check the database for that user.
    
4.  Send an email to that user.
    

If you use callbacks for all of this, you have to put a callback inside a callback, inside another callback. Your code starts to push further and further to the right side of your screen.

```javascript
// This is famous "Callback Hell"
fs.readFile('user-list.txt', function(error, users) {
    findUser(users, function(error, specificUser) {
        getDatabaseInfo(specificUser, function(error, dbInfo) {
            sendEmail(dbInfo, function(error, success) {
                console.log("Finally done!");
            });
        });
    });
});
```

### **Diagram: Callback Execution Chain**

```text
Step 1: Read File
  \
   Step 2: Find User
     \
      Step 3: Get Database Info
        \
         Step 4: Send Email
```

This messy, sideways pyramid shape is called **Callback Hell**. It is extremely hard to read, and if an error happens, it is very difficult to figure out which step broke.

## **The Better Way: Promises**

To fix Callback Hell, JavaScript developers created **Promises**.

Think of a Promise like ordering food at a busy fast-food restaurant. You pay for your meal, and the cashier gives you a buzzer. You don't have your food yet, but you have a *promise* that you will get it soon.

In Node.js, a Promise is an object that represents a task that has not finished yet. Instead of nesting functions inside of functions, you can chain them in a straight, clean line using `.then()`.

Let's look at how that same messy code looks when we use Promises:

```javascript
const fs = require('fs').promises;

console.log("Chef: Starting async tasks with Promises...");

fs.readFile('user.json', 'utf8')
    .then((userData) => {
        console.log("Got User");
        return fs.readFile('posts.json', 'utf8'); // Return a new promise
    })
    .then((postData) => {
        console.log("Got Posts");
        return fs.readFile('comments.json', 'utf8');
    })
    .then((commentData) => {
        console.log("Got everything!");
    })
    .catch((err) => {
        // One single place to handle any error in the chain!
        console.error("Chef: Something went wrong in the kitchen:", err);
    });
```

## **Benefits of Promises**

As you can see, Promises are a massive upgrade. Here is why developers love them:

1.  **Readability:** The code reads from top to bottom, almost like a plain English sentence. (Do this, `.then` do this, `.then` do this).
    
2.  **Easy Error Handling:** In the old callback days, you had to write `if (error)` on every single step. With promises, you just put one `.catch()` block at the very bottom. If any step fails, it jumps straight to the catch block!
    

### **Diagram: Promise Lifecycle Flow**

```text
                      +--> [ Fulfilled ] --> Triggers .then()
                     /     (Success!)
[ Pending Promise ] +      
(Waiting for data)   \     
                      +--> [ Rejected ] ---> Triggers .catch()
                           (Error!)
```