Difference between Promise and Async/Await in Node

Last Updated : 04 Apr, 2025

In Node.js, both Promises and Async/Await are used for handling asynchronous operations, but they differ in how they simplify the code. Promises provide a simple way to work with callbacks, while Async/Await offers a more readable and synchronous way to handle asynchronous tasks.

Promise

A Promise is an object representing the eventual completion (or failure) of an asynchronous operation. It provides a cleaner way to handle asynchronous operations compared to traditional callback functions, helping to avoid "callback hell."

Key Characteristics of Promises

States: A Promise can be in one of three states.
- Pending: Initial state, neither fulfilled nor rejected.
- Fulfilled: Operation completed successfully.
- Rejected: Operation failed.
Methods:
- then(): Executes when the Promise is fulfilled.
- catch(): Executes when the Promise is rejected.
- finally(): Executes regardless of the Promise's outcome.

Error Handling of Promises

To handle the outcome of a Promise:

Resolved Promise: Use the .then() method.
Rejected Promise: Use the .catch() method.
Regardless of Outcome: Use .finally() to execute code after handling the Promise.

Example: During database server data retrieval, a Promise remains pending until successful data reception (resolved state) or unsuccessful retrieval (rejected state).

JavaScript

const promise = new Promise(function (resolve, reject) {
    const string1 = "geeksforgeeks";
    const string2 = "geeksforgeeks";
    if (string1 === string2) {
        resolve();
    } else {
        reject();
    }
});

promise
    .then(function () {
        console.log("Promise resolved successfully");
    })
    .catch(function () {
        console.log("Promise is rejected");
    });

Output:

Promise resolved successfully

Async/Await

Async/Await is a simpler way to work with Promises in JavaScript. It lets you write code that handles tasks which take time, like fetching data, in a way like regular, step-by-step code. The async keyword is used to create a function that returns a Promise, while the await keyword pauses the function's execution until the Promise is done.

Key Characteristics of async/await

Async Functions: An async function returns a Promise. It allows the use of the await keyword inside it.
Await: The await keyword pauses the execution of the async function until the Promise is resolved or rejected.

Error Handling in Async/Await:

Error handling is done using try and catch blocks, similar to synchronous code.

Resolved Promise: Inside try.
Rejected Promise: Inside catch.
Regardless of Outcome: You can still use .finally() after try or catch.

Example:

JavaScript

const helperPromise = function () {
    const promise = new Promise(function (resolve, reject) {
        const x = "geeksforgeeks";
        const y = "geeksforgeeks";
        if (x === y) {
            resolve("Strings are same");
        } else {
            reject("Strings are not same");
        }
    });

    return promise;
};

async function demoPromise() {
    try {
        let message = await helperPromise();
        console.log(message);
    } catch (error) {
        console.log("Error: " + error);
    }
}

demoPromise();

Output:

Strings are same