How can you synchronize a sequence of Promises in JavaScript?

Synchronizing a Sequence of Promises

JavaScript promises provide a powerful mechanism for handling asynchronous operations. However, there are situations where we need to synchronize the execution of promises in a specific order. This is particularly challenging when we want to avoid early execution or interruptions from later promises.

Manual Iteration with Promise Chaining

One straightforward approach to synchronizing promises is to iterate through them manually, chaining promises one after another:

function sequence(arr) {
  let index = 0;

  function next() {
    if (index < arr.length) {
      return arr[index++].then(next).catch(e => Promise.reject(e));
    }
  }

  return next();
}

This function iterates through the array of promises, resolving each one in sequence and handling any rejections.

Using Bluebird Promise Library

Bluebird is a popular promise library that provides additional features for concurrency control, including:

Promise.mapSeries(arr, function(item) {
  return processItem(item);
}).then(function(results) {
  // process final results here
}).catch(function(err) {
  // process array here
});

Using ES7 Async/Await

ES7 introduced async/await syntax, which simplifies asynchronous programming and provides a natural way to sequence promises:

async function processArray(array, fn) {
  let results = [];
  for (let i = 0; i < array.length; i++) {
    let r = await fn(array[i]);
    results.push(r);
  }
  return results;    // will be resolved value of promise
}

Avoiding Early Execution

To prevent early execution of promises, you can create them within the loop instead of declaring them ahead of time. This ensures that only the current promise is executed before the next one is created.

function sequenceDynamic(nextPromise) {
  let index = 0;

  function next() {
    const promise = nextPromise(index);
    if (promise) {
      return promise.then(() => next(++index)).catch(e => Promise.reject(e));
    }
  }

  return next();
}

This updated function takes a callback function that returns the next promise to execute. The function continues iterating as long as the callback returns valid promises.

Conclusion

Synchronizing promises in a specific order can be achieved through manual iteration, the Bluebird library, async/await syntax, or by avoiding early execution. It's important to select the approach that best suits your application and development environment.

The above is the detailed content of How can you synchronize a sequence of Promises in JavaScript?. For more information, please follow other related articles on the PHP Chinese website!