Entendendo promessas no Node.js

Pelo que entendi, há três maneiras de chamar código assíncrono:

1. Eventos, por exemplo request.on("event", callback);
2. Retornos de chamada, por exemplo fs.open(path, flags, mode, callback);
3. Promessas

Encontrei a biblioteca de promessas de nós, mas não a entendo.

Alguém poderia explicar quais são as promessas e por que devo usá-las?

Além disso, por que ele foi removido do Node.js.

As promessas no node.js prometeram fazer algum trabalho e, em seguida, tiveram retornos de chamada separados que seriam executados para obter êxito e falha, além de lidar com tempos limite. Outra maneira de pensar nas promessas no node.js era que eles eram emissores que podiam emitir apenas dois eventos: sucesso e erro.

O interessante das promessas é que você pode combiná-las em cadeias de dependência (faça a Promessa C somente quando a Promessa A e a Promessa B estiverem concluídas).

Ao removê-los do core node.js, criou a possibilidade de construir módulos com diferentes implementações de promessas que podem ficar no topo do core. Alguns deles são promessa de nó e futuros .

Como essa pergunta ainda tem muitos pontos de vista (como o meu), eu gostaria de salientar que:

1. A promessa do nó parece um pouco morta para mim (a última confirmação ocorreu há cerca de um ano) e quase não contém testes.
2. o módulo de futuros parece muito inchado para mim e está mal documentado (e acho que as convenções de nomenclatura são ruins)
3. O melhor caminho a seguir parece ser a estrutura q , que é ativa e bem documentada.

Uma promessa é uma "coisa" que representa os resultados "eventuais" de uma operação, por assim dizer. O ponto a ser observado aqui é que ele abstrai os detalhes de quando algo acontece e permite que você se concentre no que deve acontecer depois que algo acontecer. Isso resultará em um código limpo e sustentável, onde, em vez de ter um retorno de chamada dentro de um retorno de chamada, seu código será parecido com:

 var request = new Promise(function(resolve, reject) {
   //do an ajax call here. or a database request or whatever.
   //depending on its results, either call resolve(value) or reject(error)
   //where value is the thing which the operation's successful execution returns and
   //error is the thing which the operation's failure returns.
 });

 request.then(function successHandler(result) {
   //do something with the result
 }, function failureHandler(error) {
  //handle
 });

As especificações das promessas afirmam que uma promessa é

then

O método deve retornar uma nova promessa que é cumprida quando o retorno de chamada successHandler ou failHandler especificado é concluído. Isso significa que você pode encadear promessas quando tiver um conjunto de tarefas assíncronas que precisam ser executadas e ter certeza de que o seqüenciamento de operações é garantido como se você tivesse usado retornos de chamada. Portanto, em vez de passar um retorno de chamada para dentro de um retorno de chamada, o código com promessas encadeadas se parece com:

var doStuff = firstAsyncFunction(url) {
                return new Promise(function(resolve, reject) {
                       $.ajax({
                        url: url,
                        success: function(data) {
                            resolve(data);
                        },
                        error: function(err) {
                             reject(err); 
                        } 
                  });
               };
doStuff
  .then(secondAsyncFunction) //returns a promise
  .then(thirdAsyncFunction); //returns a promise

Para saber mais sobre as promessas e por que elas são super legais, confira o blog de Domenic: http://domenic.me/2012/10/14/youre-missing-the-point-of-promises/

Este novo tutorial sobre promessas do autor do PouchDB é provavelmente o melhor que eu já vi em qualquer lugar. Ele cobre sabiamente os erros clássicos de novatos, mostrando os padrões de uso corretos e até alguns anti-padrões que ainda são comumente usados ​​- mesmo em outros tutoriais !!

• http://pouchdb.com/2015/05/18/we-have-a-problem-with-promises.html

Aproveitar!

PS: Eu não respondi algumas outras partes desta pergunta, pois elas foram bem cobertas por outras.

Mike Taulty tem uma série de vídeos , cada um com menos de dez minutos, descrevendo como a biblioteca WinJS Promise funciona.

Esses vídeos são bastante informativos e Mike consegue mostrar o poder da API Promise com alguns exemplos de código bem escolhidos.

var twitterUrl = "http://search.twitter.com/search.json?q=windows";
var promise = WinJS.xhr({ url: twitterUrl });

 promise = promise.then(
     function (xhr) {
     },
     function (xhr) {
         // handle error
     });

O tratamento de como as exceções são tratadas é particularmente bom.

Apesar das referências do WinJs, esta é uma série de vídeos de interesse geral, porque a API do Promise é amplamente semelhante em muitas implementações.

Responda Por Favor é uma implementação leve do Promise que passa no conjunto de testes Promise / A +. Eu gosto bastante da API, porque é semelhante em estilo à interface do WinJS.

Atualização abr-2014

Aliás, a biblioteca WinJS agora é de código aberto .

Outra vantagem das promessas é que o tratamento de erros e a ativação e captura de exceções são muito melhores do que tentar lidar com isso com retornos de chamada.

A biblioteca bluebird implementa promessas e fornece ótimos rastreamentos de pilha longa, é muito rápida e alerta sobre erros não detectados. Também é mais rápido e usa menos memória do que as outras bibliotecas promissoras, de acordo com http://bluebirdjs.com/docs/benchmarks.html

O que exatamente é uma promessa?

Uma promessa é simplesmente um objeto que representa o resultado de uma operação assíncrona. Uma promessa pode estar em qualquer um dos três estados a seguir:

pendente :: Este é o estado inicial, significa que a promessa não é cumprida nem rejeitada.

cumprida : significa que a promessa foi cumprida, significa que o valor representado pela promessa está pronto para ser usado.

rejeitado :: Isso significa que as operações falharam e, portanto, não podem cumprir a promessa. Além dos estados, existem três entidades importantes associadas a promessas que realmente precisamos entender

1. executor function :: executor function define a operação assíncrona que precisa ser executada e cujo resultado é representado pela promessa. Inicia a execução assim que o objeto de promessa é inicializado.

2. resolve :: resolve é um parâmetro passado para a função executora e, caso o executor seja executado com êxito, essa resolução será chamada passando o resultado.

3. Reject :: Reject é outro parâmetro passado para a função executora e é usado quando a função executora falha. O motivo da falha pode ser passado para a rejeição.

Portanto, sempre que criamos um objeto de promessa, devemos fornecer Executor, Resolve e Reject.

Referência :: Promessas

Também estive procurando promessas no node.js recentemente. Até o momento, o when.js parece ser o caminho a seguir devido à sua velocidade e uso de recursos, mas a documentação do q.js me deu um entendimento muito melhor. Portanto, use when.js, mas o q.js documenta para entender o assunto.

A partir dos q.js leia-me no github:

Se uma função não puder retornar um valor ou lançar uma exceção sem bloquear, poderá retornar uma promessa. Uma promessa é um objeto que representa o valor de retorno ou a exceção lançada que a função pode eventualmente fornecer. Uma promessa também pode ser usada como proxy para um objeto remoto para superar a latência.

O objeto Promise representa a conclusão ou falha de uma operação assíncrona.

Portanto, para implementar uma promessa, você precisa de duas partes:

1. Criando Promessa:

O construtor da promessa aceita uma função chamada executor que possui 2 parâmetros para resolver e rejeitar.

function example(){
   return new Promise (function(resolve , reject){   //return promise object
      if(success){
         resolve('success');  //onFullfiled
      }else{
         reject('error');     //onRejected
      }
   })
}

2. Promessa de Manuseio:

O objeto Promise possui 3 métodos para manipular objetos Promise: -

1.Promise.prototype.catch (onRejected)

2.Promise.prototype.then (onFullfiled)

3.Promise.prototype.finally (onFullfiled, onRejected)

example.then((data) =>{
  //handles resolved data
  console.log(data); //prints success     
}).catch((err) => {
  //handles rejected error 
  console.log(err);  //prints error
})