Understanding Promise all in JavaScript: A Guide with Examples

The Role of Promise.all

Promise.all is a powerful method that takes an iterable of Promise instances as an input and returns a single Promise that resolves when all of the input Promises have resolved, or rejects as soon as one of the input Promises is rejected. This method is particularly useful for handling multiple asynchronous operations that are not dependent on each other to complete.

Promise.all([fetch(‘url1’), fetch(‘url2’)])

 .then(responses => Promise.all(responses.map(res => res.json())))

 .then(data => console.log(data))

 .catch(error => console.error(“Failed to fetch:”, error));

Promise.all is used when you have multiple asynchronous operations and you want to wait for all of them to complete. It takes an array of promises and returns a single Promise that resolves when all of the promises have resolved.

const promise1 = Promise.resolve(3);

const promise2 = 42;

const promise3 = new Promise((resolve, reject) => {

 setTimeout(resolve, 100, ‘foo’);


Promise.all([promise1, promise2, promise3]).then(values => {

 console.log(values); // [3, 42, “foo”]


In the asynchronous world of JavaScript, managing multiple promises simultaneously can be a crucial skill. Promise.all is a powerful method that helps developers handle multiple promises concurrently. In this blog post, we’ll explore how Promise.all works, its benefits, and provide practical examples to illustrate its usage.

What is Promise.all?

Promise.all is a method that takes an array of promises and returns a single Promise that resolves when all of the promises in the array have resolved or when one of them is rejected. This feature is particularly useful when you need to coordinate multiple asynchronous operations that are independent from one another but collectively determine a single outcome.

How Does Promise.all Work?

The function Promise.all returns a new promise that fulfills when all of the promises in the iterable argument have been fulfilled, or gets rejected as soon as one of the promises in the iterable argument is rejected. If a promise is rejected, the return promise is immediately rejected with the reason of the first promise that was rejected.

Benefits of Using Promise.all

  • Efficiency: It runs multiple promises in parallel, reducing the overall time you might have waited if you ran each promise sequentially.
  • Simplicity: It simplifies the control flow of handling multiple promises, making your code cleaner and easier to read.
  • Error handling: It ensures that if any promise in the array fails, the whole array is rejected, allowing for easier debugging and error handling.

Example Use Cases

Let’s dive into some practical examples to see Promise.all in action.

Example 1: Data Fetching

Imagine you need to fetch user data from multiple endpoints and render it simultaneously:

function fetchUserData(userId) {
return fetch(`https://api.example.com/users/${userId}`);

function fetchUserPosts(userId) {
return fetch(`https://api.example.com/users/${userId}/posts`);

Promise.all([fetchUserData(1), fetchUserPosts(1)])
.then(responses => Promise.all(responses.map(res => res.json())))
.then(data => {
const [userData, userPosts] = data;
console.log('User Data:', userData);
console.log('User Posts:', userPosts);
.catch(error => console.error('Failed to fetch data:', error));

Example 2: Database Operations

Suppose you need to insert multiple records into a database and want to ensure all inserts are completed before proceeding:

const dbPromise1 = database.insert({ table: 'users', data: { name: 'Alice' } });
const dbPromise2 = database.insert({ table: 'items', data: { itemName: 'Book' } });

Promise.all([dbPromise1, dbPromise2])
.then(() => console.log('All records inserted successfully'))
.catch(error => console.error('Error inserting records:', error));

Handling Errors

It’s important to handle errors in Promise.all since the rejection of any single promise will cause the entire promise array to reject. You can manage errors effectively using catch:

Promise.all([promise1, promise2])
.then([result1, result2] => {
console.log('Results:', result1, result2);
.catch(error => {
console.error('Error with one of the promises:', error);


Promise.all is a versatile and essential tool in the arsenal of a JavaScript developer, particularly when dealing with multiple asynchronous operations. By understanding and using Promise.all, developers can write more efficient and readable code, making handling multiple promises a breeze.