Usando la clase Promise

Recomiendo echar un vistazo a los documentos de Promise de MDN que ofrecen un buen punto de partida para usar Promises. Alternativamente, estoy seguro de que hay muchos tutoriales disponibles en línea. :)

Nota: Los navegadores modernos ya son compatibles con la especificación ECMAScript 6 de Promises (consulte los documentos de MDN vinculados anteriormente) y asumo que desea utilizar la implementación nativa, sin bibliotecas de terceros.

En cuanto a un ejemplo real...

El principio básico funciona así:

1. Su API se llama
2. Creas un nuevo objeto Promise, este objeto toma una sola función como parámetro constructor
3. La función proporcionada es llamada por la implementación subyacente y la función recibe dos funciones: resolve y reject
4. Una vez que haga su lógica, llame a uno de estos para cumplir la Promesa o rechazarla con un error

Esto puede parecer mucho, así que aquí hay un ejemplo real.

 exports.getUsers = function getUsers () { // Return the Promise right away, unless you really need to // do something before you create a new Promise, but usually // this can go into the function below return new Promise((resolve, reject) => { // reject and resolve are functions provided by the Promise // implementation. Call only one of them. // Do your logic here - you can do WTF you want.:) connection.query('SELECT * FROM Users', (err, result) => { // PS. Fail fast! Handle errors first, then move to the // important stuff (that's a good practice at least) if (err) { // Reject the Promise with an error return reject(err) } // Resolve (or fulfill) the promise with data return resolve(result) }) }) } // Usage: exports.getUsers() // Returns a Promise! .then(users => { // Do stuff with users }) .catch(err => { // handle errors })

Uso de la función de lenguaje asíncrono/en espera (Node.js >=7.6)

En Node.js 7.6, el compilador de JavaScript v8 se actualizó con compatibilidad con async/await . Ahora puede declarar funciones como async , lo que significa que automáticamente devuelven una Promise que se resuelve cuando la función asíncrona completa su ejecución. Dentro de esta función, puede usar la palabra clave await para esperar hasta que se resuelva otra Promesa.

Aquí hay un ejemplo:

 exports.getUsers = async function getUsers() { // We are in an async function - this will return Promise // no matter what. // We can interact with other functions which return a // Promise very easily: const result = await connection.query('select * from users') // Interacting with callback-based APIs is a bit more // complicated but still very easy: const result2 = await new Promise((resolve, reject) => { connection.query('select * from users', (err, res) => { return void err ? reject(err) : resolve(res) }) }) // Returning a value will cause the promise to be resolved // with that value return result }

Con bluebird puede usar Promise.promisifyAll (y Promise.promisify ) para agregar métodos listos para Promise a cualquier objeto.

 var Promise = require('bluebird'); // Somewhere around here, the following line is called Promise.promisifyAll(connection); exports.getUsersAsync = function () { return connection.connectAsync() .then(function () { return connection.queryAsync('SELECT * FROM Users') }); };

Y usa así:

 getUsersAsync().then(console.log);

o

 // Spread because MySQL queries actually return two resulting arguments, // which Bluebird resolves as an array. getUsersAsync().spread(function(rows, fields) { // Do whatever you want with either rows or fields. });

Adición de trituradores

Bluebird admite muchas características, una de ellas son los desechadores, le permite desechar de manera segura una conexión después de que finalizó con la ayuda de Promise.using y Promise.prototype.disposer . Aquí hay un ejemplo de mi aplicación:

 function getConnection(host, user, password, port) { // connection was already promisified at this point // The object literal syntax is ES6, it's the equivalent of // {host: host, user: user, ... } var connection = mysql.createConnection({host, user, password, port}); return connection.connectAsync() // connect callback doesn't have arguments. return connection. .return(connection) .disposer(function(connection, promise) { //Disposer is used when Promise.using is finished. connection.end(); }); }

Entonces úsalo así:

 exports.getUsersAsync = function () { return Promise.using(getConnection()) .then(function (connection) { return connection.queryAsync('SELECT * FROM Users') }); };

Esto finalizará automáticamente la conexión una vez que la promesa se resuelva con el valor (o se rechace con un Error ).

Node.js versión 8.0.0+:

Ya no tiene que usar bluebird para prometer los métodos de la API del nodo. Porque, a partir de la versión 8+, puede usar util.promisify nativo:

 const util = require('util'); const connectAsync = util.promisify(connection.connectAsync); const queryAsync = util.promisify(connection.queryAsync); exports.getUsersAsync = function () { return connectAsync() .then(function () { return queryAsync('SELECT * FROM Users') }); };

Ahora, no tiene que usar ninguna librería de terceros para hacer la promesa.