path: root/files/uk/web/javascript/reference/global_objects/promise/all/index.html

---
title: Promise.all()
slug: Web/JavaScript/Reference/Global_Objects/Promise/all
tags:
  - ECMAScript 2015
  - JavaScript
  - Promise
  - метод
translation_of: Web/JavaScript/Reference/Global_Objects/Promise/all
---
<div>{{JSRef}}</div>

<p>Метод <strong><code>Promise.all()</code></strong> повертає єдиний {{jsxref("Promise","проміс")}}, який виконується, коли усі проміси, передані у вигляді ітерабельного об'єкта, були виконані, або коли ітерабельний об'єкт не містить жодного проміса. Він відхиляється з причиною першого відхиленого проміса.</p>

<p>Зазвичай використовується після того, як були запущені асинхронні задачі, що виконуються конкурентно, та були створені проміси для їхніх результатів, щоб мати змогу зачекати, доки усі задачі не будуть виконані.</p>

<div>{{EmbedInteractiveExample("pages/js/promise-all.html")}}</div>

<p class="hidden">The source for this interactive demo is stored in a GitHub repository. If you'd like to contribute to the interactive demo project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</p>

<h2 id="Синтаксис">Синтаксис</h2>

<pre class="syntaxbox">Promise.all(<var>iterable</var>);</pre>

<h3 id="Параметри">Параметри</h3>

<dl>
 <dt><code>iterable</code></dt>
 <dd><a href="/uk/docs/Web/JavaScript/Reference/Протоколи_перебору#Протокол_ітерабельного_обєкта">Ітерабельний об'єкт</a>, такий як {{jsxref("Array")}}.</dd>
</dl>

<h3 id="Значення_що_повертається">Значення, що повертається</h3>

<ul>
 <li><strong>Вже вирішений</strong> {{jsxref("Promise", "проміс")}}, якщо переданий <var>ітерабельний об'єкт</var> є порожнім.</li>
 <li><strong>Асинхронно вирішений</strong> {{jsxref("Promise","проміс")}}, якщо переданий <var>ітерабельний об'єкт</var> не містить промісів. Зауважте, що Google Chrome 58 у цьому випадку повертає <strong>вже вирішений</strong> проміс.</li>
 <li>{{jsxref("Promise","Проміс")}} <strong>у стані очікування</strong> у всіх інших випадках. Цей повернений проміс далі вирішується/відхиляється <strong>асинхронно</strong> (як тільки стек стане порожнім), коли усі проміси у переданому <var>ітерабельному об'єкті</var> будуть вирішені, або якщо будь-який з промісів буде відхилено. Дивіться приклад щодо "Асинхронності або синхронності Promise.all" нижче. Повернені значення будуть розташовані у порядку, в якому були передані проміси, незалежно від порядку завершення.</li>
</ul>

<h2 id="Опис">Опис</h2>

<p>Цей метод може бути корисним для збирання результатів множини промісів.</p>

<h3 id="Виконання">Виконання</h3>

<p>Повернений проміс виконується з масивом, що містить <strong>усі </strong>значення <var>ітерабельного об'єкта,</var> переданого в якості аргумента (також значення, що не є промісами).</p>

<ul>
 <li>Якщо був переданий порожній <var>ітерабельний об'єкт</var>, тоді цей метод вертає (синхронно) вже вирішений проміс.</li>
 <li>Якщо усі передані проміси виконуються, або це не проміси, проміс, повернений <code>Promise.all</code>, виконується асинхронно.</li>
</ul>

<h3 id="Відхилення">Відхилення</h3>

<p>Якщо будь-який з переданих промісів відхиляється, <code>Promise.all</code> асинхронно відхиляється зі значенням відхиленого проміса, незалежно від того, чи були вирішені інші проміси.</p>

<h2 id="Приклади">Приклади</h2>

<h3 id="Використання_Promise.all">Використання <code>Promise.all</code></h3>

<p><code>Promise.all</code> чекає на усі виконання (або на перше відхилення).</p>

<pre class="brush: js">var p1 = Promise.resolve(3);
var p2 = 1337;
var p3 = new Promise((resolve, reject) =&gt; {
  setTimeout(() =&gt; {
    resolve("foo");
  }, 100);
});

Promise.all([p1, p2, p3]).then(values =&gt; {
  console.log(values); // [3, 1337, "foo"]
});</pre>

<p>Якщо <var>ітерабельний об'єкт</var> містить значення, що не є промісами, вони будуть проігноровані, але все одно міститимуться у поверненому масиві проміса (якщо проміс виконається):</p>

<pre class="brush: js">// рахуватиметься, ніби передано порожній ітерабельний об'єкт, отже, він виконається
var p = Promise.all([1,2,3]);
// рахуватиметься, ніби переданий ітерабельний об'єкт містить лише вирішений проміс зі значенням "444", отже, він виконається
var p2 = Promise.all([1,2,3, Promise.resolve(444)]);
// рахуватиметься, ніби переданий ітерабельний об'єкт містить лише відхилений проміс зі значенням "555", отже, він буде відхилений
var p3 = Promise.all([1,2,3, Promise.reject(555)]);

// використовуючи setTimeout, ми можемо виконати код після того, як стек стане порожнім
setTimeout(function() {
    console.log(p);
    console.log(p2);
    console.log(p3);
});

// виводить
// Promise { &lt;state&gt;: "fulfilled", &lt;value&gt;: Array[3] }
// Promise { &lt;state&gt;: "fulfilled", &lt;value&gt;: Array[4] }
// Promise { &lt;state&gt;: "rejected", &lt;reason&gt;: 555 }</pre>

<h3 id="Асинхронність_або_синхронність_Promise.all">Асинхронність або синхронність <code>Promise.all</code></h3>

<p>Наступний приклад демонструє асинхронність (або синхронність, якщо передано порожній <var>ітерабельний об'єкт</var>) <code>Promise.all</code>:</p>

<pre class="brush: js">// ми передаємо в якості аргумента масив вже вирішених промісів,
// щоб запустити Promise.all якомога швидше
var resolvedPromisesArray = [Promise.resolve(33), Promise.resolve(44)];

var p = Promise.all(resolvedPromisesArray);
// негайно виводимо значення p
console.log(p);

// використовуючи setTimeout, ми можемо виконати код після того, як стек стане порожнім
setTimeout(function() {
    console.log('стек тепер порожній');
    console.log(p);
});

// виводить, в порядку:
// Promise { &lt;state&gt;: "pending" }
// стек тепер порожній
// Promise { &lt;state&gt;: "fulfilled", &lt;value&gt;: Array[2] }
</pre>

<p>Те саме відбувається, якщо <code>Promise.all</code> відхиляється:</p>

<pre class="brush: js">var mixedPromisesArray = [Promise.resolve(33), Promise.reject(44)];
var p = Promise.all(mixedPromisesArray);
console.log(p);
setTimeout(function() {
    console.log('стек тепер порожній');
    console.log(p);
});

// виводить
// Promise { &lt;state&gt;: "pending" }
// стек тепер порожній
// Promise { &lt;state&gt;: "rejected", &lt;reason&gt;: 44 }
</pre>

<p><code>Promise.all</code> вирішується синхронно <strong>лише тоді</strong>, коли переданий <var>ітерабельний об'єкт</var> є порожнім:</p>

<pre class="brush: js">var p = Promise.all([]); // буде негайно вирішений
// значення, що не є промісами, будуть проігноровані, але обчислення відбуватиметься асинхронно
var p2 = Promise.all([1337, "привіт"]);
console.log(p);
console.log(p2)
setTimeout(function() {
    console.log('стек тепер порожній');
    console.log(p2);
});

// виводить
// Promise { &lt;state&gt;: "fulfilled", &lt;value&gt;: Array[0] }
// Promise { &lt;state&gt;: "pending" }
// стек тепер порожній
// Promise { &lt;state&gt;: "fulfilled", &lt;value&gt;: Array[2] }</pre>

<h3 id="Швидке_відхилення_у_Promise.all">Швидке відхилення у <code>Promise.all</code></h3>

<p><code>Promise.all</code> відхиляється, якщо будь-який з його елементів було відхилено. Наприклад, якщо ви передаєте чотири проміси, які вирішуються після затримки, та один проміс, який негайно відхиляється, тоді <code>Promise.all</code> буде негайно відхилено.</p>

<pre class="brush: js">var p1 = new Promise((resolve, reject) =&gt; {
  setTimeout(() =&gt; resolve('один'), 1000);
});
var p2 = new Promise((resolve, reject) =&gt; {
  setTimeout(() =&gt; resolve('два'), 2000);
});
var p3 = new Promise((resolve, reject) =&gt; {
  setTimeout(() =&gt; resolve('три'), 3000);
});
var p4 = new Promise((resolve, reject) =&gt; {
  setTimeout(() =&gt; resolve('чотири'), 4000);
});
var p5 = new Promise((resolve, reject) =&gt; {
  reject(new Error('відхилено'));
});


// Використовуємо .catch:
Promise.all([p1, p2, p3, p4, p5])
.then(values =&gt; {
  console.log(values);
})
.catch(error =&gt; {
  console.error(error.message)
});

//Виведе:
//"відхилено"

</pre>

<p>Цю поведінку можливо змінити, обробивши можливі відхилення:</p>

<pre class="brush: js">var p1 = new Promise((resolve, reject) =&gt; {
  setTimeout(() =&gt; resolve('p1_відкладене_вирішення'), 1000);
});

var p2 = new Promise((resolve, reject) =&gt; {
  reject(new Error('p2_негайне_відхилення'));
});

Promise.all([
  p1.catch(error =&gt; { return error }),
  p2.catch(error =&gt; { return error }),
]).then(values =&gt; {
  console.log(values[0]) // "p1_відкладене_вирішення"
  console.error(values[1]) // "Error: p2_негайне_відхилення"
})
</pre>

<h2 id="Специфікації">Специфікації</h2>

<table class="standard-table">
 <tbody>
  <tr>
   <th scope="col">Специфікація</th>
  </tr>
  <tr>
   <td>{{SpecName('ESDraft', '#sec-promise.all', 'Promise.all')}}</td>
  </tr>
 </tbody>
</table>

<h2 id="Сумісність_з_веб-переглядачами">Сумісність з веб-переглядачами</h2>

<p class="hidden">To contribute to this compatibility data, please write a pull request against this repository: <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p>

<p>{{Compat("javascript.builtins.Promise.all")}}</p>

<h2 id="Див._також">Див. також</h2>

<ul>
 <li>{{jsxref("Promise")}}</li>
 <li>{{jsxref("Promise.race()")}}</li>
</ul>