Text of developer.mozilla.org › en-US › docs › Web › JavaScript › Reference › Global_Objects › Prom… as Styx crawled it on Nov 18, 2026. The page may have changed since. Only its words are kept, without pictures or layout, and only the first part of a long page.

Open the live page

Promise.all() - JavaScript | MDN

Skip to main content Skip to search Promise.all() Baseline Widely available This feature is well established and works across many devices and browser versions. It’s been available across browsers since July 2015. See full compatibility Learn more The Promise.all() static method takes an iterable of promises as input and returns a single Promise . This returned promise fulfills when all of the input's promises fulfill (including when an empty iterable is passed), with an array of the fulfillment values.

It rejects when any of the input's promises rejects, with this first rejection reason. Try it 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); }); // Expected output: Array [3, 42, "foo"] Syntax js Promise.all(iterable) Parameters iterable An iterable (such as an Array ) of promises.

These values are awaited , so other thenables are also resolved, while non-thenables are returned as-is. Return value A Promise that is: Already fulfilled , if the iterable passed is empty. Asynchronously fulfilled , when all the promises in the given iterable fulfill. The fulfillment value is an array of fulfillment values, in the order of the promises passed, regardless of completion order. If the iterable passed is non-empty but contains no pending promises, the returned promise is still asynchronously (instead of synchronously) fulfilled.

Asynchronously rejected , when any of the promises in the given iterable rejects. The rejection reason is the rejection reason of the first promise that was rejected. Description The Promise.all() method is one of the promise concurrency methods. It can be useful for aggregating the results of multiple promises. It is typically used when there are multiple related asynchronous tasks that the overall code relies on to work successfully — all of whom we want to fulfill before the code execution continues.

Promise.all() will reject immediately upon any of the input promises rejecting. In comparison, the promise returned by Promise.allSettled() will wait for all input promises to complete, regardless of whether or not one rejects. Use allSettled() if you need the final result of every promise in the input iterable. Like other promise combinators, Promise.all() immediately marks all promises as "handled" when it is called (by calling their .then() methods).

Subsequent rejections after the first rejection will be ignored, and will not trigger any unhandledrejection events. Rejecting the returned promise does not cancel the remaining operations or unsubscribe the handlers attached to their promises. Repeatedly passing a long-lived pending promise to Promise.all() can accumulate handlers on that promise even when another input rejects each time. Examples Using Promise.all() Promise.all waits for all fulfillments (or the first rejection). js const p1 = Promise.resolve(3); const p2 = 1337; const p3 = new Promise((resolve, reject) => { setTimeout(() => { resolve("foo"); }, 100); }); Promise.all([p1, p2, p3]).then((values) => { console.log(values); // [3, 1337, "foo"] }); If the iterable contains non-promise values, they will be ignored, but still counted in the returned promise array value (if the promise is fulfilled): js // All values are non-promises, so the returned promise gets fulfilled const p = Promise.all([1, 2, 3]); // The only input promise is already fulfilled, // so the returned promise gets fulfilled const p2 = Promise.all([1, 2, 3, Promise.resolve(444)]); // One (and the only) input promise is rejected, // so the returned promise gets rejected const p3 = Promise.all([1, 2, 3, Promise.reject(new Error("bad"))]); // Using setTimeout, we can execute code after the queue is empty setTimeout(() => { console.log(p); console.log(p2); console.log(p3); }); // Logs: // Promise { <state>: "fulfilled", <value>: Array[3] } // Promise { <state>: "fulfilled", <value>: Array[4] } // Promise { <state>: "rejected", <reason>: Error: bad } Destructuring the result You will find destructuring very useful if you are batching together a known number of tasks. js // With then() Promise.all([p1, p2, p3]).then(([a, b, c]) => { console.log(a, b, c); // 3 1337 "foo" }); // With await const [a, b, c] = await Promise.all([p1, p2, p3]); Be careful: if the original promises and the result variables' order don't match, you may run into subtle bugs.

The Promise.allKeyed() method solves exactly this problem. Asynchronicity or synchronicity of Promise.all This following example demonstrates the asynchronicity of Promise.all when a non-empty iterable is passed: js // Passing an array of promises that are already resolved, // to trigger Promise.all as soon as possible const resolvedPromisesArray = [Promise.resolve(33), Promise.resolve(44)]; const p = Promise.all(resolvedPromisesArray); // Immediately logging the value of p console.log(p); // Using setTimeout, we can execute code after the queue is empty setTimeout(() => { console.log("the queue is now empty"); console.log(p); }); // Logs, in order: // Promise { <state>: "pending" } // the queue is now empty // Promise { <state>: "fulfilled", <value>: Array[2] } The same thing happens if Promise.all rejects: js const mixedPromisesArray = [ Promise.resolve(33), Promise.reject(new Error("bad")), ]; const p = Promise.all(mixedPromisesArray); console.log(p); setTimeout(() => { console.log("the queue is now empty"); console.log(p); }); // Logs: // Promise { <state>: "pending" } // the queue is now empty // Promise { <state>: "rejected", <reason>: Error: bad } Promise.all resolves synchronously if and only if the iterable passed is empty: js const p = Promise.all([]); // Will be immediately resolved const p2 = Promise.all([1337, "hi"]); // Non-promise values are ignored, but the evaluation is done asynchronously console.log(p); console.log(p2); setTimeout(() => { console.log("the queue is now empty"); console.log(p2); }); // Logs: // Promise { <state>: "fulfilled", <value>: Array[0] } // Promise { <state>: "pending" } // the queue is now empty // Promise { <state>: "fulfilled", <value>: Array[2] } Using Promise.all() with async functions Within async functions , it's very common to "over-await" your code.

For example, given the following functions: js function promptForDishChoice() { return new Promise((resolve, reject) => { const dialog = document.createElement("dialog"); dialog.innerHTML = ` <form method="dialog"> <p>What would you like to eat?</p> <select> <option value="pizza">Pizza</option> <option value="pasta">Pasta</option> <option value="salad">Salad</option> </select> <menu> <li><button value="cancel">Cancel</button></li> <li><button type="submit" value="ok">OK</button></li> </menu> </form> `; dialog.addEventListener("close", () => { if (dialog.returnValue === "ok") { resolve(dialog.querySelector("select").value); } else { reject(new Error("User canceled dialog")); } }); document.body.appendChild(dialog); dialog.showModal(); }); } async function fetchPrices() { const response = await fetch("/prices"); return await response.json(); } You may write a function like this: js async function getPrice() { const choice = await promptForDishChoice(); const prices = await fetchPrices(); return prices[choice]; } However, note that the execution of promptForDishChoice and fetchPrices don't depend on the result of each other.

While the user is choosing their dish, it's fine for the prices to be fetched in the background, but in the code above, the await operator causes the async function to pause until the choice is made, and then again until the prices are fetched. We can use Promise.all to run them concurrently, so that the user doesn't have to wait for the prices to be fetched before the result is given: js async function getPrice() { const [choice, prices] = await Promise.all([ promptForDishChoice(), fetchPrices(), ]); return prices[choic

The rest of this page is on the live site.