javascript - promises - Comprender las promesas en node.js

promises js

Question

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

1. Eventos: ej. request.on("event", callback);
2. Devolución de llamada: ej. fs.open(path, flags, mode, callback);
3. Promesas

Encontré una biblioteca de la promesa https://github.com/kriszyp/node-promise pero no lo entiendo.

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

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

Answer 1

Dado que esta pregunta todavía tiene muchos puntos de vista (como el mío), quería señalar que:

1. node-promise me parece bastante muerto (el último commit fue hace aproximadamente 1 año) y no contiene casi ninguna prueba.
2. El módulo de futuros me parece muy abultado 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 es tanto activo como bien documentado.

Answer 2

Este nuevo tutorial sobre Promesas del autor de PouchDB es probablemente el mejor que he visto en mi vida. Sabiamente cubre los errores de novato clásicos que muestran los patrones correctos de uso 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.

Answer 3

Las promesas en node.js prometían hacer algo de trabajo y luego tenían devoluciones de llamadas independientes que se ejecutarían en caso de éxito o fracaso, así como también el manejo de tiempos de espera. Otra forma de pensar en las promesas de 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 Promesa C solo cuando Promesa A y Promesa B estén completas).

Al eliminarlos del núcleo node.js, se 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 https://github.com/kriszyp/node-promise y Futures .

Answer 4

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

Estos videos son bastante informativos, y Mike logra mostrar el poder de la Promise API 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 Promise API es muy similar en sus muchas implementaciones.

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

Actualización de abril de 2014

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

Answer 5

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 llamadas.

La biblioteca bluebird implementa promesas y te da grandes rastros de pila larga, es muy rápido y advierte sobre errores no detectados. También es más rápido y utiliza menos memoria que las otras bibliotecas de promesa, de acuerdo con http://bluebirdjs.com/docs/benchmarks.html

Answer 6

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 en q.js me dio una mejor comprensión. Así que use when.js pero los documentos de q.js para entender el tema.

Desde el readme 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 en su lugar. 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 usar como un proxy para un objeto remoto para superar la latencia.

Answer 7

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 cuando sucede algo y le permite concentrarse en lo que debería suceder después de que algo sucede. Esto dará como resultado un código limpio y mantenible en el que, 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í como:

 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 debería devolver una nueva promesa que se cumple cuando se completa el answerHandler o la devolución de llamada fallida. Esto significa que puede encadenar promesas cuando tiene que realizar un conjunto de tareas asincrónicas y tener la seguridad de que la secuencia de las operaciones está garantizada como si hubiera usado 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 acerca de las promesas y por qué son geniales, visite el blog de Domenic: http://domenic.me/2012/10/14/youre-missing-the-point-of-promises/

Answer 8

¿Qué es exactamente una Promesa?

Una promesa es simplemente un objeto que representa el resultado de una operación asincrónica. 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 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 promesas que realmente debemos entender

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

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

3. reject :: reject es otro parámetro que se pasa a la función del ejecutor, y se usa cuando falla la función del ejecutor. El motivo de la falla se puede pasar al rechazo.

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

Referencia :: Promises