Comprender las promesas en Node.js

Por lo que he entendido, hay tres formas de llamar a un código asincrónico:

1. Eventos, p. Ej. request.on("event", callback);
2. Callbacks, p. Ej. fs.open(path, flags, mode, callback);
3. Promesas

Encontré la biblioteca de promesa de nodo pero no la consigo.

¿Podría alguien explicar de qué se tratan las promesas y por qué debería usarlas?

Además, ¿por qué se eliminó de Node.js?

Las promesas en node.js prometieron hacer algo de trabajo y luego tuvieron devoluciones de llamada separadas que se ejecutarían para el éxito y el fracaso, así como para manejar los tiempos de espera. Otra forma de pensar en las promesas en node.js era que eran emisores que solo podían emitir dos eventos: éxito y error.

Lo bueno de las promesas es que puedes combinarlas en cadenas de dependencia (haz la promesa C solo cuando se completen la promesa A y la promesa B).

Al eliminarlos del núcleo node.js, creó la posibilidad de construir módulos con diferentes implementaciones de promesas que pueden ubicarse en la parte superior del núcleo. Algunos de estos son promesa de nodo y futuros .

Dado que esta pregunta todavía tiene muchas opiniones (como la mía), quería señalar que:

1. La promesa de nodo me parece bastante muerta (la última confirmación fue hace aproximadamente 1 año) y casi no contiene pruebas.
2. El módulo de futuros me parece muy hinchado y está mal documentado (y creo que las convenciones de nombres son simplemente malas)
3. El mejor camino a seguir parece ser el marco q , que está activo y bien documentado.

Una promesa es una "cosa" que representa los resultados "eventuales" de una operación, por así decirlo. El punto a tener en cuenta aquí es que, abstrae los detalles de cuándo sucede algo y le permite centrarse en lo que debería suceder después de que algo suceda. Esto dará como resultado un código limpio y fácil de mantener donde, en lugar de tener una devolución de llamada dentro de una devolución de llamada dentro de una devolución de llamada, su código se verá algo así:

 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
 });

La especificación de las promesas establece que una promesa

then

El método debe devolver una nueva promesa que se cumpla cuando finalice la devolución de llamada de SuccessHandler o la falla. Esto significa que puede encadenar promesas cuando tiene un conjunto de tareas asíncronas que deben realizarse y asegurarse de que la secuencia de operaciones está garantizada como si hubiera utilizado devoluciones de llamada. Entonces, en lugar de pasar una devolución de llamada dentro de una devolución de llamada dentro de una devolución de llamada, el código con promesas encadenadas se ve así:

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 más sobre las promesas y por qué son súper geniales, visite el blog de Domenic: http://domenic.me/2012/10/14/youre-missing-the-point-of-promises/

Este nuevo tutorial sobre Promesas del autor de PouchDB es probablemente el mejor que he visto en mi vida. Cubre sabiamente los errores clásicos de novato que muestran patrones de uso correctos e incluso algunos antipatrones que todavía se usan comúnmente, ¡incluso en otros tutoriales!

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

¡Disfrutar!

PD: No respondí algunas otras partes de esta pregunta, ya que han sido bien cubiertas por otros.

Mike Taulty tiene una serie de videos , cada uno de ellos de menos de diez minutos de duración, que describe cómo funciona la biblioteca WinJS Promise.

Estos videos son bastante informativos, y Mike logra mostrar el poder de la API Promise con algunos ejemplos de código bien elegidos.

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
     });

El tratamiento de cómo se manejan las excepciones es particularmente bueno.

A pesar de las referencias de WinJs, esta es una serie de videos de interés general, porque la API Promise es ampliamente similar en todas sus implementaciones.

RSVP es una implementación ligera de Promise que supera el conjunto de pruebas Promise / A +. Me gusta bastante la API, porque es similar en estilo a la interfaz WinJS.

Actualización abr-2014

Por cierto, la biblioteca WinJS ahora es de código abierto .

Otra ventaja de las promesas es que el manejo de errores y el lanzamiento y captura de excepciones es mucho mejor que tratar de manejar eso con devoluciones de llamada.

La biblioteca de bluebird implementa promesas y le brinda excelentes trazas largas de la pila, es muy rápida y advierte sobre errores no detectados. También es más rápido y usa menos memoria que las otras bibliotecas de promesa, de acuerdo con http://bluebirdjs.com/docs/benchmarks.html

¿Qué es exactamente una promesa?

Una promesa es simplemente un objeto que representa el resultado de una operación asíncrona. Una promesa puede ser en cualquiera de los siguientes 3 estados:

pendiente :: Este es el estado inicial, significa que la promesa no se cumple ni se rechaza.

cumplido :: Esto significa que la promesa se ha cumplido, significa que el valor representado por la promesa está listo para ser utilizado.

rechazado :: Esto significa que las operaciones fallaron y, por lo tanto, no pueden cumplir la promesa. Además de los estados, hay tres entidades importantes asociadas a las promesas que realmente necesitamos entender

1. función ejecutor :: la función ejecutor define la operación asíncrona que debe realizarse y cuyo resultado está representado por la promesa. Comienza la ejecución tan pronto como se inicializa el objeto de promesa.

2. resolve :: resolve es un parámetro pasado a la función ejecutor, y en caso de que el ejecutor se ejecute con éxito, esta resolución se llama pasar el resultado.

3. rechazar :: rechazar es otro parámetro pasado a la función ejecutora, y se usa cuando falla la función ejecutora. La razón de la falla se puede pasar al rechazo.

Entonces, cada vez que creamos un objeto de promesa, tenemos que proporcionar Ejecutor, Resolver y Rechazar.

Referencia :: Promesas

También he estado buscando promesas en node.js recientemente. Hasta la fecha, when.js parece ser el camino a seguir debido a su velocidad y uso de recursos, pero la documentación sobre q.js me dio una mejor comprensión. Entonces use when.js pero los documentos q.js para entender el tema.

Del archivo léame de q.js en github:

Si una función no puede devolver un valor o lanzar una excepción sin bloquear, puede devolver una promesa. Una promesa es un objeto que representa el valor de retorno o la excepción lanzada que la función puede proporcionar eventualmente. Una promesa también se puede utilizar como proxy para que un objeto remoto supere la latencia.

El objeto de promesa representa la finalización o falla de una operación asincrónica.

Entonces, para implementar una promesa, necesita dos partes:

1. Creando promesa:

El constructor de la promesa acepta una función llamada ejecutor que tiene 2 parámetros resolver y rechazar.

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

2. Promesa de manejo:

El objeto de promesa tiene 3 métodos para manejar objetos de promesa: -

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
})