How make promise execute synchronously?

In JavaScript, Promises are inherently asynchronous and do not block the execution flow. However, there are several ways to manage and coordinate the execution of multiple Promises to achieve sequential execution. Here, 'synchronous execution' typically refers to executing Promises sequentially, i.e., one after another completes.

Method One: Using async and await

This is the simplest and most intuitive way to handle Promises. async and await allow you to write asynchronous code in a synchronous manner.

javascript
async function processPromisesSequentially() {
  const result1 = await promise1();
  console.log(result1); // Wait for promise1 to resolve before proceeding

  const result2 = await promise2();
  console.log(result2); // Wait for promise2 to resolve before proceeding

  const result3 = await promise3();
  console.log(result3); // Wait for promise3 to resolve before proceeding
}

Method Two: Chaining

By chaining .then() methods after a Promise, you can execute multiple Promises sequentially. Each .then() processes the result of the previous Promise and returns a new Promise.

javascript
promise1()
  .then(result1 => {
    console.log(result1);
    return promise2();
  })
  .then(result2 => {
    console.log(result2);
    return promise3();
  })
  .then(result3 => {
    console.log(result3);
  });

Method Three: Using reduce

If you need to handle an array of Promises and execute them sequentially, you can use the reduce method of arrays.

javascript
function runPromisesInSequence(promises) {
  return promises.reduce((promiseChain, currentPromise) => {
    return promiseChain.then(chainResults =>
      currentPromise.then(currentResult => [...chainResults, currentResult])
    );
  }, Promise.resolve([]));
}

const promiseArray = [promise1, promise2, promise3];
runPromisesInSequence(promiseArray)
  .then(arrayOfResults => {
    console.log(arrayOfResults);
  });

Example Scenario

Suppose you need to read user data from a database, then request different APIs based on this data, and must complete them in sequence because each step depends on the result of the previous step. In this case, using async and await is often the most direct and clear approach.

javascript
async function fetchUserDataAndUpdate() {
  try {
    const user = await getUserFromDatabase(userId);
    const updatedProfile = await updateProfileWithAPI(user);
    const confirmation = await sendEmailToUser(updatedProfile);
    console.log('Process completed:', confirmation);
  } catch (error) {
    console.error('An error occurred:', error);
  }
}

The above methods provide several approaches to achieve sequential execution of Promises, each with appropriate use cases. Typically, async and await offer the most intuitive and manageable solution.