Usando promessas em JavaScript

Periodicamente, publicamos materiais que de uma maneira ou de outra estão relacionados ao uso de promessas em JavaScript.


Por que tanta atenção está voltada para promessas? Acreditamos que o ponto principal é que essa tecnologia é muito procurada e é bastante difícil de entender.

Portanto, se você deseja entender melhor as promessas, oferecemos uma tradução do próximo artigo sobre este tópico. Seu autor diz que ele desenvolve Java e PHP nos últimos 10 anos, mas durante todo esse tempo ele procura com interesse o JavaScript. Recentemente, ele decidiu se envolver seriamente em JS, e as promessas se tornaram o primeiro assunto que o interessou.



Acreditamos que este material será interessante para desenvolvedores iniciantes que acham que, embora usem promessas, não os entendem bem o suficiente. É possível que a história de alguém que veja o JavaScript com uma nova aparência e queira explicar aos outros o que ele mesmo entendeu, não acreditando que algumas coisas sejam compreensíveis para todos e sem explicação, ajude os iniciantes a dominar os mecanismos do JavaScript.

JavaScript através dos olhos de um iniciante

Quem começa a escrever em JavaScript, pode sentir o que é chamado de "fora de lugar". Alguns dizem que JS é uma linguagem de programação síncrona, outros dizem que é assíncrona. Um novato ouve sobre o código que bloqueia o encadeamento principal e sobre o código que não o bloqueia, sobre padrões de design baseados em eventos, sobre o ciclo de vida de eventos, sobre a pilha de chamadas de função, sobre a fila de eventos e sua ascensão, sobre polyfills. Ele descobre que existem coisas como Babel, Angular, React, Vue e uma infinidade de outras bibliotecas. Se você acabou de se reconhecer como um “novato” - não se preocupe. Você não é o primeiro nem o último. Existe até um termo para isso - o chamado "fadiga do JavaScript". Lucas F Costa falou apropriadamente sobre esse assunto: "O cansaço do JavaScript é algo que pode ser observado quando as pessoas usam ferramentas que não precisam para resolver problemas que não têm ".

Mas não vamos falar sobre coisas tristes. Portanto, o JavaScript é uma linguagem de programação síncrona que, graças ao mecanismo de retorno de chamada, permite chamar funções da mesma maneira que nas linguagens assíncronas.

Uma história simples sobre promessas

A palavra promessa se traduz em promessa. Objetos de promessa na programação, que chamamos de "promessas", são muito semelhantes às promessas usuais que as pessoas fazem umas às outras na vida real. Então, vamos falar sobre essas promessas primeiro.

Na Wikipedia, você pode encontrar a seguinte definição da palavra "promessa": "obrigação, o consentimento de alguém para cumprir algo ou, pelo contrário, não fazer". No dicionário de Ozhegov, "promessa" é "um compromisso voluntário de fazer alguma coisa".

Então, o que sabemos sobre promessas?

1. Uma promessa lhe garante que algo será feito. Não importa quem faz exatamente isso: quem fez a promessa, ou outra pessoa, a pedido de quem fez a promessa. Uma promessa dá confiança em algo, com base nessa confiança, quem recebeu a promessa pode, por exemplo, fazer alguns planos.
2. Uma promessa pode ser cumprida ou não.
3. Se a promessa for cumprida, então, como resultado, você espera que algo que possa ser usado no futuro realize quaisquer ações ou implemente planos.
4. Se a promessa não for cumprida, você desejará descobrir por que quem a deu não pôde cumpri-la. Depois de descobrir o motivo do ocorrido e ter certeza de que a promessa não foi cumprida, você pode pensar no que fazer a seguir ou em como lidar com a situação.
5. Depois de lhe ter sido prometido algo, tudo o que você tem é algum tipo de garantia. Você não pode tirar proveito do que lhe foi prometido imediatamente. Você pode determinar por si mesmo o que precisa fazer se a promessa for cumprida (portanto, você receberá a promessa) e o que precisa fazer se for quebrado (nesse caso, você sabe o motivo do que aconteceu e, portanto, pode pensar em um plano de ações de backup). )
6. É provável que a pessoa que fez a promessa simplesmente desapareça. Nesses casos, é útil que a promessa esteja vinculada a algum tipo de prazo. Por exemplo, se quem lhe deu a promessa não aparecer em 10 dias, você pode assumir que ele teve alguns problemas e ele quebrou a promessa. Como resultado, mesmo que quem fez a promessa cumpra em 15 dias, isso não importa, então você já está agindo no plano alternativo, não confiando na promessa.

Agora vá para JavaScript.

Promessas de JavaScript

Eu tenho uma regra: fazer JavaScript, eu sempre ler a documentação , que está disponível no MDN. Parece-me que esse recurso se compara favoravelmente com os outros na especificidade e clareza da apresentação. Portanto, enquanto estudava as promessas, me familiarizei com o material relevante e experimentei o código para me acostumar com as novas construções de sintaxe.

Para entender as promessas, você precisa lidar com duas coisas principais. A primeira é a criação de promessas. O segundo é o processamento dos resultados retornados pelas promessas. Embora a maior parte do código que escrevemos tenha como objetivo trabalhar com promessas criadas, por exemplo, por certas bibliotecas, um entendimento completo dos mecanismos de trabalho das promessas será, sem dúvida, útil. Além disso, para um programador que já tem alguma experiência, saber como criar promessas é tão importante quanto saber trabalhar com elas.

Criar promessas

Veja como as promessas são criadas:

new Promise( /* executor */ function(resolve, reject) { ... } ); 

O construtor aceita uma função que executa certas ações, que chamamos de executor . Essa função usa dois parâmetros - resolve e reject , que, por sua vez, também são funções. As promessas geralmente são usadas para executar operações assíncronas ou códigos que podem bloquear o encadeamento principal, por exemplo, um que funcione com arquivos, faz chamadas de API, faz consultas de banco de dados, lida com E / S e assim por diante. O início dessas operações assíncronas é realizado na função executor . Se a operação assíncrona for concluída com êxito, o resultado esperado da promessa será retornado chamando a função de resolve . A situação em que essa função é chamada é determinada pelo criador da promessa. Da mesma forma, quando ocorre um erro, as informações sobre o que aconteceu são retornadas chamando a função de reject .

Agora que sabemos, em termos gerais, como criar promessas, criaremos uma promessa simples para entender melhor tudo.

 var keepsHisWord; keepsHisWord = true; promise1 = new Promise(function(resolve, reject) { if (keepsHisWord) {   resolve("The man likes to keep his word"); } else {   reject("The man doesnt want to keep his word"); } }); console.log(promise1); 

Aqui está o que esse código produzirá:


Promise possui um estado (PromiseStatus) e um valor (PromiseValue)

Como nossa promessa é instantaneamente resolvida, não podemos investigar seu estado inicial. Portanto, vamos criar uma nova promessa, que, para resolução, precisa de algum tempo. A maneira mais fácil de fazer isso é usando a função setTimeout .

 promise2 = new Promise(function(resolve, reject) { setTimeout(function() {   resolve({     message: "The man likes to keep his word",     code: "aManKeepsHisWord"   }); }, 10 * 1000); }); console.log(promise2); 

Nesse código, é criada uma promessa que certamente será resolvida em 10 segundos. Isso nos dá a oportunidade de analisar o estado de uma promessa não autorizada.


Promessa não resolvida

Após 10 segundos, a promessa será resolvida. Como resultado, o PromiseStatus e o PromiseValue serão atualizados de acordo. Como você pode ver, neste exemplo, alteramos a função chamada quando a promessa foi resolvida com sucesso, agora ela retorna não uma sequência comum, mas um objeto. Isso é feito para demonstrar a capacidade de retornar estruturas de dados complexas usando a função de resolve .


Promessa resolvida após 10 segundos e retornando um objeto

Vamos agora dar uma olhada na promessa, que decidimos não permitir, mas rejeitar. Para fazer isso, modificamos o código que já foi usado no primeiro exemplo.

 keepsHisWord = false; promise3 = new Promise(function(resolve, reject) { if (keepsHisWord) {   resolve("The man likes to keep his word"); } else {   reject("The man doesn't want to keep his word"); } }); console.log(promise3); 

Como não lidamos com a situação de rejeição da promessa, uma mensagem de erro será exibida no console do navegador (o Google Chrome é usado aqui). Falaremos mais sobre isso abaixo.


Promessa rejeitada

Agora, analisando todos os três exemplos, podemos ver que três valores diferentes podem aparecer no PromiseStatus : pending (pendente), resolved (resolução bem-sucedida) e rejected (rejeitado). Quando uma promessa é criada, no PromiseStatus estará pending e no PromiseValue será undefined . Esses valores permanecerão até que a promessa seja resolvida ou rejeitada. Quando uma promessa está em um estado resolved ou rejected , é chamada de promessa settled . Essa promessa passou de um estado de espera para um estado em que ele tem um estado resolved ou um estado rejected .

Agora que aprendemos como as promessas são criadas, podemos conversar sobre como processar o que elas retornam. Para descobrir isso, precisamos entender a estrutura do objeto Promise .

Objeto Prometido

De acordo com a documentação do MDN, um objeto Promise é o resultado de uma conclusão bem-sucedida ou malsucedida de uma operação assíncrona.

O objeto Promise possui métodos estáticos e métodos de protótipo do objeto. Os métodos estáticos podem ser chamados sem criar uma instância do objeto e, para chamar os métodos de protótipo, você precisa de uma instância do objeto Promise . Lembre-se de que os métodos estático e regular retornam objetos Promise . Isso facilita o trabalho.

Prometer métodos de protótipo de objeto

Vamos falar primeiro sobre os métodos de protótipo do objeto Promise . Existem três desses métodos. Não esqueça que esses métodos podem ser chamados na instância do objeto Promise e que eles próprios retornam as promessas. Graças a todos esses métodos, você pode atribuir manipuladores que respondem a alterações no status das promessas. Como já vimos, quando uma promessa é criada, ela está em um estado pending . Quando uma promessa é transferida para um estado resolved ou rejected , pelo menos um dos seguintes métodos será chamado:

 Promise.prototype.catch(onRejected) Promise.prototype.then(onFulfilled, onRejected) Promise.prototype.finally(onFinally) 

Abaixo está um diagrama da operação da promessa e dos eventos que levam à chamada dos .catch e .catch . Como esses métodos retornam objetos Promise , suas chamadas podem ser encadeadas, isso também é refletido no diagrama. Se a promessa usar o método .finally , será chamada quando a promessa for movida para o estado settled , independentemente de a promessa ter sido resolvida ou rejeitada com êxito.


Esquema de trabalho Promis (imagem retirada daqui )

Aqui está uma pequena história. Você é estudante e pede à sua mãe que lhe compre um telefone celular. Ela diz: "Se nossa economia for superior ao custo do telefone, eu o comprarei". Agora reconte esta história em JavaScript.

 var momsPromise = new Promise(function(resolve, reject) { momsSavings = 20000; priceOfPhone = 60000; if (momsSavings > priceOfPhone) {   resolve({     brand: "iphone",     model: "6s"   }); } else {   reject("We donot have enough savings. Let us save some more money."); } }); momsPromise.then(function(value) { console.log("Hurray I got this phone as a gift ", JSON.stringify(value)); }); momsPromise.catch(function(reason) { console.log("Mom coudn't buy me the phone because ", reason); }); momsPromise.finally(function() { console.log(   "Irrespecitve of whether my mom can buy me a phone or not, I still love her" ); }); 

Aqui está o que esse código produzirá:


Mamãe não cumpriu uma promessa

Se momsSavings o valor da variável momsSavings para 200.000, a mãe poderá comprar um presente para o filho. Nesse caso, o código acima produzirá o seguinte.


Mamãe manteve uma promessa

Agora vamos imaginar que o código em questão foi projetado como uma biblioteca e usamos essa biblioteca. Vamos falar sobre o uso efetivo dos .catch e .catch .

Como o método onFulfilled pode ser atribuído tanto ao manipulador onFulfilled que é chamado quando a promessa é resolvida com êxito quanto ao manipulador onRejected que é chamado quando a promessa é rejeitada, em vez de usar o método .catch e o método .catch , podemos obter o mesmo efeito com apenas um .then método. Aqui está o que pode parecer:

 momsPromise.then( function(value) {   console.log("Hurray I got this phone as a gift ", JSON.stringify(value)); }, function(reason) {   console.log("Mom coudn't buy me the phone because ", reason); } ); 

Este é um exemplo .catch , mas para impedir a legibilidade do código, é melhor usar os métodos .catch e .catch vez de um .catch universal.

Para que esses exemplos sejam executados em um navegador e, especificamente, no Google Chrome, tentei evitar dependências externas. Para entender melhor o que consideraremos mais adiante, vamos criar uma função que retorna uma promessa, cuja resolução ou rejeição ocorre aleatoriamente. Isso nos permitirá experimentar vários cenários de trabalho com promessas. Para entender os recursos das funções assíncronas, definiremos atrasos aleatórios em nossas promessas. Como precisamos de números aleatórios, criamos uma função que retorna um número aleatório entre x e y . Aqui está a função.

 function getRandomNumber(start = 1, end = 10) { //,      start  end >=1  end > start return parseInt(Math.random() * end) % (end-start+1) + start; } 

Agora crie uma função que retorne promessas. promiseTRRARNOSG . O nome dessa função representa promiseThatResolvesRandomlyAfterRandomNumnberOfSecondsGenerator , ou seja, é um gerador de promessas que são resolvidas ou rejeitadas aleatoriamente após um número aleatório de segundos. Essa função criará uma promessa que será permitida ou rejeitada após um período aleatório entre 2 e 10 segundos. Para permitir ou rejeitar aleatoriamente uma promessa, obtemos um número aleatório entre 1 e 10. Se esse número for maior que 5, a promessa será permitida; caso contrário, será rejeitada.

 function getRandomNumber(start = 1, end = 10) { //,      start  end >=1  end > start return (parseInt(Math.random() * end) % (end - start + 1)) + start; } var promiseTRRARNOSG = (promiseThatResolvesRandomlyAfterRandomNumnberOfSecondsGenerator = function() { return new Promise(function(resolve, reject) {   let randomNumberOfSeconds = getRandomNumber(2, 10);   setTimeout(function() {     let randomiseResolving = getRandomNumber(1, 10);     if (randomiseResolving > 5) {       resolve({         randomNumberOfSeconds: randomNumberOfSeconds,         randomiseResolving: randomiseResolving       });     } else {       reject({         randomNumberOfSeconds: randomNumberOfSeconds,         randomiseResolving: randomiseResolving       });     }   }, randomNumberOfSeconds * 1000); }); }); var testProimse = promiseTRRARNOSG(); testProimse.then(function(value) { console.log("Value when promise is resolved : ", value); }); testProimse.catch(function(reason) { console.log("Reason when promise is rejected : ", reason); }); //             ,    .     ,  - . for (i=1; i<=10; i++) { let promise = promiseTRRARNOSG(); promise.then(function(value) {   console.log("Value when promise is resolved : ", value); }); promise.catch(function(reason) {   console.log("Reason when promise is rejected : ", reason); }); } 

Execute esse código no console do navegador para ver como se comportam as promessas permitidas e rejeitadas. A seguir, falaremos sobre como você pode criar muitas promessas e verificar os resultados de sua implementação, usando outros mecanismos.

Métodos estáticos de um objeto Promise

Existem quatro métodos estáticos de um objeto Promise .

Aqui estão dois métodos - Promise.reject(reason) e Promise.resolve(value) , que permitem criar, respectivamente, promessas rejeitadas e permitidas.

Veja como trabalhar com o método Promise.reject , que cria promessas rejeitadas.

 var promise3 = Promise.reject("Not interested"); promise3.then(function(value){ console.log("This will not run as it is a rejected promise. The resolved value is ", value); }); promise3.catch(function(reason){ console.log("This run as it is a rejected promise. The reason is ", reason); }); 

Aqui está um exemplo usando o método Promise.resolve que cria promessas resolvidas com sucesso.

 var promise4 = Promise.resolve(1); promise4.then(function(value){ console.log("This will run as it is a resovled promise. The resolved value is ", value); }); promise4.catch(function(reason){ console.log("This will not run as it is a resolved promise", reason); }); 

Note-se que uma promessa pode ter vários manipuladores. Por exemplo, com base no exemplo anterior, você pode obter o código mostrado abaixo.

 var promise4 = Promise.resolve(1); promise4.then(function(value){ console.log("This will run as it is a resovled promise. The resolved value is ", value); }); promise4.then(function(value){ console.log("This will also run as multiple handlers can be added. Printing twice the resolved value which is ", value * 2); }); promise4.catch(function(reason){ console.log("This will not run as it is a resolved promise", reason); }); 

Aqui está o que é exibido no console do navegador:


Usando vários .then ao trabalhar com o Promise

Os dois métodos a seguir, Promise.all e Promise.race , foram projetados para trabalhar com conjuntos de promessas. Se, para resolver um determinado problema, for necessário processar várias promessas, é mais conveniente colocá-las em uma matriz e executar as ações necessárias com elas. Para entender a essência dos métodos aqui considerados, não poderemos usar nossa função conveniente promiseTRRARNOSG , já que o resultado de seu trabalho depende muito da vontade do caso. Será mais conveniente usar algo que produz promessas mais previsíveis, o que nos permitirá entender seu comportamento. Portanto, criaremos duas novas funções. Um deles ( promiseTRSANSG ) criará promessas que são resolvidas após n segundos, o segundo ( promiseTRJANSG ) - promessas que são rejeitadas após n segundos.

 var promiseTRSANSG = (promiseThatResolvesAfterNSecondsGenerator = function( n = 0 ) { return new Promise(function(resolve, reject) {   setTimeout(function() {     resolve({       resolvedAfterNSeconds: n     });   }, n * 1000); }); }); var promiseTRJANSG = (promiseThatRejectsAfterNSecondsGenerator = function( n = 0 ) { return new Promise(function(resolve, reject) {   setTimeout(function() {     reject({       rejectedAfterNSeconds: n     });   }, n * 1000); }); }); 

Agora, usaremos essas funções para entender os recursos do método Promise.all .

▍ Método Promise.all

Na documentação do MDN, você pode descobrir que o Promise.all(iterable) retorna uma promessa que será resolvida quando todas as promessas aprovadas como argumento iterable forem iterable ou quando esse argumento não contiver promessas. Essa promessa será rejeitada se alguma das promessas transferidas for rejeitada.
Vejamos alguns exemplos.

Exemplo No. 1

Todas as promessas serão permitidas aqui. Este cenário é mais comum.

 console.time("Promise.All"); var promisesArray = []; promisesArray.push(promiseTRSANSG(1)); promisesArray.push(promiseTRSANSG(4)); promisesArray.push(promiseTRSANSG(2)); var handleAllPromises = Promise.all(promisesArray); handleAllPromises.then(function(values) { console.timeEnd("Promise.All"); console.log("All the promises are resolved", values); }); handleAllPromises.catch(function(reason) { console.log("One of the promises failed with the following reason", reason); }); 

Aqui está o que esse código produzirá para o console:


Todas as promessas permitidas

Após analisar os resultados deste exemplo, duas observações importantes podem ser feitas.

Primeiramente, a terceira promessa, cuja resolução leva 2 segundos, é concluída antes da segunda, mas, como pode ser visto na saída gerada pelo código, a ordem das promessas na matriz é preservada.

Em segundo lugar, o código contém um cronômetro usado para descobrir quanto tempo leva para executar a instrução Promise.all .

Se as promessas fossem executadas seqüencialmente, o tempo de execução desta instrução seria de 7 segundos (1 + 4 + 2). No entanto, o timer informa que toda a operação levou 4 segundos se arredondarmos o resultado. Isso prova que todas as promessas são executadas em paralelo.

Exemplo No. 2

Agora considere a situação em que não há promessas na matriz passada para Promise.all. Acredito que este é o caso de uso menos comum para esse recurso.

 console.time("Promise.All"); var promisesArray = []; promisesArray.push(1); promisesArray.push(4); promisesArray.push(2); var handleAllPromises = Promise.all(promisesArray); handleAllPromises.then(function(values) { console.timeEnd("Promise.All"); console.log("All the promises are resolved", values); }); handleAllPromises.catch(function(reason) { console.log("One of the promises failed with the following reason", reason); }); 

Aqui está a saída que esse código irá gerar:


Invoque Promise.all e passe uma matriz que não contenha promessas para esse método

Como não há promessas na matriz, Promise.all quase instantaneamente.

Exemplo No. 3

Agora, vejamos o que acontece quando uma das promessas aprovadas para Promise.all é rejeitada.

 console.time("Promise.All"); var promisesArray = []; promisesArray.push(promiseTRSANSG(1)); promisesArray.push(promiseTRSANSG(5)); promisesArray.push(promiseTRSANSG(3)); promisesArray.push(promiseTRJANSG(2)); promisesArray.push(promiseTRSANSG(4)); var handleAllPromises = Promise.all(promisesArray); handleAllPromises.then(function(values) { console.timeEnd("Promise.All"); console.log("All the promises are resolved", values); }); handleAllPromises.catch(function(reason) { console.timeEnd("Promise.All"); console.log("One of the promises failed with the following reason ", reason); }); 

Como você pode ver nos resultados da execução do código mostrados abaixo, a execução do Promise.all para após a primeira promessa rejeitada com a saída da mensagem que essa promessa fornece.


Execução para após a primeira promessa rejeitada

Método Promise.race

O MDN relata que o Promise.race(iterable) retorna uma promessa permitida ou rejeitada com um valor ou motivo de rejeição após uma das promessas transmitidas ser respectivamente permitida ou rejeitada.

Vejamos exemplos de trabalho com Promise.race .

Exemplo No. 1

Ele mostra o que acontece quando uma das promessas aprovadas no Promise.race é resolvida antes de qualquer outra pessoa.

 console.time("Promise.race"); var promisesArray = []; promisesArray.push(promiseTRSANSG(4)); promisesArray.push(promiseTRSANSG(3)); promisesArray.push(promiseTRSANSG(2)); promisesArray.push(promiseTRJANSG(3)); promisesArray.push(promiseTRSANSG(4)); var promisesRace = Promise.race(promisesArray); promisesRace.then(function(values) { console.timeEnd("Promise.race"); console.log("The fasted promise resolved", values); }); promisesRace.catch(function(reason) { console.timeEnd("Promise.race"); console.log("The fastest promise rejected with the following reason ", reason); }); 

É isso que chega ao console depois de executar este exemplo.


Promis, que resolveu mais rapidamente do que todos os outros

Todas as promessas aqui são realizadas em paralelo. A terceira promessa é resolvida após 2 segundos. Assim que isso acontece, a promessa retornada pelo Promise.race é resolvida.

Exemplo No. 2

Agora considere a situação em que uma das promessas aprovadas para Promise.race é rejeitada.

 console.time("Promise.race"); var promisesArray = []; promisesArray.push(promiseTRSANSG(4)); promisesArray.push(promiseTRSANSG(6)); promisesArray.push(promiseTRSANSG(5)); promisesArray.push(promiseTRJANSG(3)); promisesArray.push(promiseTRSANSG(4)); var promisesRace = Promise.race(promisesArray); promisesRace.then(function(values) { console.timeEnd("Promise.race"); console.log("The fasted promise resolved", values); }); promisesRace.catch(function(reason) { console.timeEnd("Promise.race"); console.log("The fastest promise rejected with the following reason ", reason); }); 

Depois de executar este exemplo, o seguinte chegará ao console:


Promessa rejeitada antes de todos os outros

As promessas aqui, como nos exemplos anteriores, são realizadas em paralelo. A quarta promessa é rejeitada após 3 segundos. Assim que isso acontece, a promessa retornada pelo Promise.race é rejeitada.

Exemplo geral e experimentos

Reuni todos os exemplos que consideramos neste material em um único local, o que tornará mais fácil experimentar com eles, para explorar vários cenários de trabalho com promessas. Esse código foi projetado para ser executado em um navegador; portanto, aqui não usamos chamadas de API, não acessamos operações de arquivos e não trabalhamos com bancos de dados. Embora tudo isso tenha aplicação no desenvolvimento de projetos reais, acredito que trabalhar com esses mecanismos pode nos distrair do nosso principal objetivo - promessas. E o uso de funções simples que simulam atrasos de tempo fornece resultados semelhantes e não nos sobrecarrega com detalhes adicionais.

Ao explorar esses exemplos, você pode experimentar o código, os valores das variáveis ​​e estudar diferentes cenários para o uso de promessas. Em particular, você pode usar uma combinação dos métodos promessaTRJANSG, promessaTRSANSG e promessaTRRARNOSG para simular vários cenários de uso de promessas, o que permitirá que você os entenda melhor. Além disso, observe que o uso do comando console.time permite descobrir o tempo necessário para executar um determinado trecho de código e, por exemplo, descobrir se as promessas são executadas em paralelo ou sequencialmente. Aqui está um link para a página principal com o código. A propósito, se você quiser, dê uma olhada na biblioteca Bluebird , que contém alguns métodos interessantes para trabalhar com promessas.

Sumário

Ofereço a você uma lista de regras às quais adiro ao trabalhar com promessas para usá-las corretamente.

1. Use promessas em situações ao trabalhar com código assíncrono ou de bloqueio.
2. Para lidar com a situação de resolver com êxito uma promessa, use o método .then ; nos casos em que a promessa for rejeitada, use .catch .
3. Use os .catch e .catch em todas as promessas.
4. - , , .finally .
5. , , , .
6. , .
7. Promise , , , .
8. Promise.all , .

, , , .

Caros leitores! , , ?