How to access Previous Promise Results in Then Chain ?

In this article, we will discuss how to access previous promise results by using “then” in JavaScript. In a series of promises connected by then, each subsequent step receives the outcome of the previous promise’s resolution. This sequential passing of results permits ongoing access and handling of prior promises’ resolved values, allowing for a continuous flow of data between asynchronous operations in the chain.

A Promise is basically an object that represents the completion (or failure) of an asynchronous operation along with its result. A promise has 3 types of states and based upon these states, the promise executes the results:

• Pending: This state represents that the promise is still in progress and hasn’t been fulfilled or rejected yet.
• Fulfilled: This state represents that the asynchronous operation is successfully completed.
• Rejected: This state represents that the asynchronous operation is rejected.

Syntax

new Promise((resolve) => {
    setTimeout(() => {
    
       // Any operations
    }, 1000);
})
.then((result) => {

    // For handling resolve 
})
.then((result) => {

   // For handling resolve 
})
.catch((error) => {

    // For Handling errors 
});

Accessing Previous Promise Results in Then Chain

In a chain of promises using the .then() method, each step handles the result passed from the prior promise, facilitating a continuous flow of data or actions between each asynchronous operation. Below are the steps to implement:

• Create a Promise named initialPromise with a setTimeout that resolves after some seconds, setting the resolved value to 50 (let).
• Chain multiple then methods to the initialPromise. In the first .then(), perform some operations after that return it to the next then. In the second .then() method, perform some operations and then return to the next .then() method.
• If any error occurs during the promise chain, it is caught by the catch method, which logs an error message.
• The code demonstrates a simple promise chain where each .then() callback operates on the result of the previous promise, and any errors are handled by the catch method.

Example: This example illustrates how we can access previous promise results in Then Chain.

Javascript

// Creating a promise

const initialPromise = new Promise((resolve, reject) => {
    setTimeout(() => {
        let ans = 50;
        resolve(ans);
    }, 3000);
});

// Chain "then" method for
// accessing the previous promise result

initialPromise
    .then((result) => {
        console.log("The first resolve output is", result);
        return result * 5 * 2;
    })
    .then((result) => {
        console.log("The second resolve output is", result);

        return result / 2;
    })
    .catch((error) => {
        console.error("The error occurred:", error);
    });

Explanation

• Creates a promise that resolves after 3 seconds with a value of 50 using setTimeout.
• The then method chains multiple operations on the resolved value. First operation multiplies the value by 5 and then by 2, logging the result. The second operation divides the result by 2, demonstrating sequential transformations.
• Utilizes a catch block to handle any errors occurring within the promise chain.
• If an error occurs during any operation, it’s caught and logged in the catch block for error handling.

Output

The first resolve output is 50
The second resolve output is 500