1 files changed, 245 insertions, 0 deletions
diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/all/index.html b/files/pt-br/web/javascript/reference/global_objects/promise/all/index.html
new file mode 100644
index 0000000000..eec13d056a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/promise/all/index.html
@@ -0,0 +1,245 @@
+---
+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="Compatibilidade_com_browsers">Compatibilidade com browsers</h2>
+
+<div class="hidden">
+<p>Para contribuir para esse dado de compatibilidade, por favor, escreva um pull request para o repositório: <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p>
+</div>
+
+<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>