path: root/files/pt-br/web/javascript/reference/global_objects/promise/all/index.html

---
title: Promise.all()
slug: Web/JavaScript/Reference/Global_Objects/Promise/all
tags:
  - ECMAScript 2015
  - ECMAScript6
  - JavaScript
  - Method
  - Promise
translation_of: Web/JavaScript/Reference/Global_Objects/Promise/all
---
<div>{{JSRef}}</div>

<p>O método <code><strong>Promise.all(iterable)</strong></code> retorna uma única {{jsxref("Promise")}} que resolve quando todas as promises no argumento iterável forem resolvidas ou quando o iterável passado como argumento não contém promises. É rejeitado com o motivo da primeira promise que foi rejeitada.</p>

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

<div class="hidden">
<p>A fonte para essa demonstração interativa está em um repositório no GitHub. Se você quiser contribuir para esse projeto de demonstrações iterativas, por favor, clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e envienos um pull request.</p>
</div>

<h2 id="Sintaxe">Sintaxe</h2>

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

<h3 id="Parâmetros">Parâmetros</h3>

<dl>
 <dt>iterable</dt>
 <dd>Um objeto <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Iteration_protocols">iterável</a>, como um {{jsxref("Array")}} ou {{jsxref("String")}}.</dd>
</dl>

<h3 id="Retorno">Retorno</h3>

<ul>
 <li>Uma {{jsxref("Promise")}}<strong> já resolvida</strong> se o iterável passado for vazio.</li>
 <li>Uma {{jsxref("Promise")}} <strong>resolvida assíncronamente</strong> se o iterável passado não conter promises. Nota, Google Chrome 58 retorna uma promise <strong>já resolvida</strong> nesse caso.</li>
 <li>Uma {{jsxref("Promise")}} <strong>pendente</strong> em todos os outros casos. Essa promise retornada é então resolvida/rejeitada <strong>assíncronamente</strong> (tão logo a pilha esteja vazia) quando todas as promises no dado iterável forem resolvidas, ou se alguma das promises for rejeitada. Veja o exemplo sobre "Assincronia ou sincronia da Promise.all" abaixo. Os valores retornados estarão na ordem em que as promises foram passadas. independentemente da ordem em que forem concluídas.</li>
</ul>

<h2 id="Descrição">Descrição</h2>

<p>Esse método pode ser usado para agregar resultados de várias promises.</p>

<h3 id="Resolução">Resolução</h3>

<p>A promise retornada é resolvida com um array contendo <strong>todos</strong> os valores dos iteráveis passados como argumento (como valores que não são promises).</p>

<ul>
 <li>Se um iterável vazio é passado, então esse método retorna (sincronamente) uma promise já resolvida.</li>
 <li>Se todas as promises passadas forem resolvidas, ou não forem promises, a promise retornada por <code>Promise.all</code> é resolvida assincronamente.</li>
</ul>

<h3 id="Rejeição">Rejeição</h3>

<p>Se qualquer uma das promises passadas for rejeitada, <code>Promise.all</code> assíncronamente é rejeitada com o valor da promise rejeitada, independentemente se outras promises foram resolvidas.</p>

<h2 id="Exemplos">Exemplos</h2>

<h3 id="Utilizando_Promise.all">Utilizando Promise.all </h3>

<p><code>Promise.all</code> espera que todas as promises sejam resolvidas (ou a primeira rejeição).</p>

<pre class="notranslate"><code class="language-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(valores=&gt; {
  console.log(valores); // [3, 1337, "foo"]
});</code>
</pre>

<p>Se o iterável conter valores que não são promises, eles serão ignorados, mas ainda serão contados no array da promise retornada (se a promise for resolvida):</p>

<pre class="notranslate"><code class="language-js">// Essa será considerada como se o iterável passado fosse vazio, logo ela será resolvido
var p = Promise.all([1,2,3]);
// Essa será considerada como se o iterável passado contém apenas a promise resolvida com o valor "444", logo ela é resolvida
var p2 = Promise.all([1,2,3, Promise.resolve(444)]);
// Esse será considerada como se o iterável passado contém apenas o valor de rejeição "555" da promise, logo ela é rejeitada
var p3 = Promise.all([1,2,3, Promise.reject(555)]);

// Utilizando setTimeout para executar código depois que a pilha estiver vazia
setTimeout(function() {
    console.log(p);
    console.log(p2);
    console.log(p3);
});

// logs
// Promise { &lt;estado&gt;: "resolvida", &lt;valor&gt;: Array[3] }
// Promise { &lt;estado&gt;: "resolvida", &lt;valor&gt;: Array[4] }
// Promise { &lt;estado&gt;: "rejeitada", &lt;razão&gt;: 555 }</code>
</pre>

<h3 id="Assincronia_ou_sincronia_da_Promise.all">Assincronia ou sincronia da Promise.all</h3>

<p>O exemplo a seguir demonstra a assincronia (ou sincronia, se o iterável passado for fazio) de <code>Promise.all</code>:</p>

<pre class="notranslate"><code class="language-js">// Passamos o argumento como um array de promises que já estão resolvidas para disparar Promise.all a mais rápido possível
var arrayPromisesResolvidas = [Promise.resolve(33), Promise.resolve(44)];

var p = Promise.all(arrayPromisesResolvidas);
// Logando imediatamente o valor de p
console.log(p);

// Utilizando setTimeout para executar código depois que a pilha estiver vazia
setTimeout(function() {
    console.log('a pilha está vazia agora');
    console.log(p);
});

// logs, em ordem:
// Promise { &lt;estado&gt;: "pendente" }
// a pilha está vazia agora
// Promise { &lt;estado&gt;: "resolvida", &lt;valor&gt;: Array[2] }</code>
</pre>

<p>A mesma coisa acontece se <code>Promise.all</code> for rejeitada:</p>

<pre class="notranslate"><code class="language-js">var arrayPromisesMisturadas = [Promise.resolve(33), Promise.reject(44)];
var p = Promise.all(arrayPromisesMisturadas);
console.log(p);
setTimeout(function() {
    console.log('a pilha está vazia agora');
    console.log(p);
});

// logs
// Promise { &lt;estado&gt;: "pendente" }
// a pilha está vazia agora
// Promise { &lt;estado&gt;: "rejeitada", &lt;razão&gt;: 44 }</code>
</pre>

<p>Mas, <code>Promise.all</code> resolve sincromamente <strong>se e somente se</strong> o iterável passado for vazio:</p>

<pre class="notranslate"><code class="language-js">var p = Promise.all([]); // será resolvida imediatamente
var p2 = Promise.all([1337, "oi"]); // um valor que não é uma promise será ignorado, mas a avaliação será feita assíncronamente
console.log(p);
console.log(p2)
setTimeout(function() {
    console.log('a pilha está vazia agora');
    console.log(p2);
});

// logs
// Promise { &lt;estado&gt;: "resolvida", &lt;valor&gt;: Array[0] }
// Promise { &lt;estado&gt;: "pendente" }
// a pilha está vazia agora
// Promise { &lt;estado&gt;: "resolvida", &lt;valor&gt;: Array[2] }</code>
</pre>

<h3 id="Comportamente_de_falhar_rapidamente_de_Promise.all">Comportamente de falhar rapidamente de Promise.all</h3>

<p><code>Promise.all</code> é rejeitada se qualquer um dos elementos for rejeitado. Por exemplo, se você passar quartro promises que resolvem após um intervalo de tempo e uma promise que rejeita imediatamente, então <code>Promise.all</code> será rejeitada imediatamente.</p>

<pre class="notranslate"><code class="language-js">var p1 = new Promise((resolve, reject) =&gt; {
  setTimeout(() =&gt; resolve('um'), 1000);
});
var p2 = new Promise((resolve, reject) =&gt; {
  setTimeout(() =&gt; resolve('dois'), 2000);
});
var p3 = new Promise((resolve, reject) =&gt; {
  setTimeout(() =&gt; resolve('três'), 3000);
});
var p4 = new Promise((resolve, reject) =&gt; {
  setTimeout(() =&gt; resolve('quatro'), 4000);
});
var p5 = new Promise((resolve, reject) =&gt; {
  reject(new Error('rejeitada'));
});


// Usando .catch:
Promise.all([p1, p2, p3, p4, p5])
.then(valores =&gt; {
  console.log(valores);
})
.catch(erro =&gt; {
  console.log(erro.message)
});

// No console:
// "rejeitada"</code>
</pre>

<p>É possível mudar esse comportamente lidando com possíveis rejeições:</p>

<pre class="brush: js line-numbers language-js notranslate"><code class="language-js">var p1 = new Promise((resolve, reject) =&gt; {
  setTimeout(() =&gt; resolve('p1_resolução_atrasada'), 1000);
});

var p2 = new Promise((resolve, reject) =&gt; {
  reject(new Error('p2_rejeição_imediata'));
});

Promise.all([
  p1.catch(erro =&gt; { return erro }),
  p2.catch(erro =&gt; { return erro }),
]).then(valores =&gt; {
  console.log(valores[0]) // "p1_resolução_atrasada"
  console.log(valores[1]) // "Erro: p2_rejeição_imediata"
})</code></pre>

<h2 id="Especificações">Especificações</h2>

<table class="standard-table">
 <tbody>
  <tr>
   <th scope="col">Especificação</th>
   <th scope="col">Status</th>
   <th scope="col">Comentário</th>
  </tr>
  <tr>
   <td>{{SpecName('ES2015', '#sec-promise.all', 'Promise.all')}}</td>
   <td>{{Spec2('ES2015')}}</td>
   <td>
    <p>Definição inicial em um padrão ECMA.</p>
   </td>
  </tr>
  <tr>
   <td>{{SpecName('ESDraft', '#sec-promise.all', 'Promise.all')}}</td>
   <td>{{Spec2('ESDraft')}}</td>
   <td></td>
  </tr>
 </tbody>
</table>

<h2 id="Browser_compatibility">Compatibilidade com navegadores</h2>

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

<h2 id="Veja_também">Veja também</h2>

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