在 Node.js 中用 promise 替换回调

使用 Promise 类

我建议看看MDN的Promise文档，它为使用Promises提供了一个很好的起点。或者，我相信网上有很多教程:)

注意：现代浏览器已经支持 ECMAScript 6 Promise 规范(参见上面链接的 MDN 文档(，我假设你想使用原生实现，没有第三方库。

至于一个实际的例子...

基本原理是这样的：

1. 您的 API 被调用
2. 您创建一个新的 Promise 对象，此对象将单个函数作为构造函数参数
3. 您提供的函数由基础实现调用，并且该函数被赋予两个函数 - resolve 和 reject
4. 完成逻辑后，调用其中一个来履行承诺或拒绝它并显示错误

这可能看起来很多，所以这里有一个实际的例子。

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

使用 async/await 语言功能 (Node.js>=7.6(

在 Node.js 7.6 中，v8 JavaScript 编译器升级为 async/await 支持。您现在可以将函数声明为async，这意味着它们会自动返回一个Promise，该在异步函数完成执行时解析。在此函数中，您可以使用 await 关键字等待另一个 Promise 解析。

下面是一个示例：

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
}

使用 bluebird，您可以使用 Promise.promisifyAll(和 Promise.promisify(将 Promise 就绪方法添加到任何对象。

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

并像这样使用：

getUsersAsync().then(console.log);

或

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

添加处理器

Bluebird支持很多功能，其中之一是处理器，它允许您在连接结束后安全地处理连接 Promise.using 和 Promise.prototype.disposer .这是我的应用程序中的一个示例：

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

然后像这样使用它：

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

This will automatically end the connection once the promise resolves with the value (or rejects with an Error).

Node.js version 8.0.0+:

You don't have to use bluebird to promisify the node API methods anymore. Because, from version 8+ you can use native util.promisify:

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

现在，不必使用任何第三方库来做承诺。

假设数据库适配器 API 本身没有Promises输出，您可以执行以下操作：

exports.getUsers = function () {
    var promise;
    promise = new Promise();
    connection.connect(function () {
        connection.query('SELECT * FROM Users', function (err, result) {
            if(!err){
                promise.resolve(result);
            } else {
                promise.reject(err);
            }
        });
    });
    return promise.promise();
};

如果数据库 API 确实支持Promises你可以执行以下操作：(在这里你看到了 Promise 的强大功能，你的回调绒毛几乎消失了(

exports.getUsers = function () {
    return connection.connect().then(function () {
        return connection.query('SELECT * FROM Users');
    });
};

使用 .then() 返回新的(嵌套(承诺。

通话方式：

module.getUsers().done(function (result) { /* your code here */ });

我为我的 Promise 使用了模型 API，您的 API 可能有所不同。如果你给我看你的API，我可以定制它。

2019

使用该本机模块const {promisify} = require('util');将普通的旧回调模式转换为承诺模式，以便您可以从async/await代码中获得好处

const {promisify} = require('util');
const glob = promisify(require('glob'));
app.get('/', async function (req, res) {
    const files = await glob('src/**/*-spec.js');
    res.render('mocha-template-test', {files});
});

设置承诺时，您需要两个参数，resolve 和 reject 。如果成功，则调用带有结果的resolve，如果失败，则调用reject带有错误。

然后你可以写：

getUsers().then(callback)

callback将被调用，其结果是从getUsers返回的 promise，即 result

例如使用 Q 库：

function getUsers(param){
    var d = Q.defer();
    connection.connect(function () {
    connection.query('SELECT * FROM Users', function (err, result) {
        if(!err){
            d.resolve(result);
        }
    });
    });
    return d.promise;   
}

下面的代码仅适用于节点 -v> 8.x

我将这个Promisized MySQL中间件用于Node.js

阅读本文使用 Node.js 8 和 Async/Await 创建 MySQL 数据库中间件

数据库.js

var mysql = require('mysql'); 
// node -v must > 8.x 
var util = require('util');

//  !!!!! for node version < 8.x only  !!!!!
// npm install util.promisify
//require('util.promisify').shim();
// -v < 8.x  has problem with async await so upgrade -v to v9.6.1 for this to work. 

// connection pool https://github.com/mysqljs/mysql   [1]
var pool = mysql.createPool({
  connectionLimit : process.env.mysql_connection_pool_Limit, // default:10
  host     : process.env.mysql_host,
  user     : process.env.mysql_user,
  password : process.env.mysql_password,
  database : process.env.mysql_database
})

// Ping database to check for common exception errors.
pool.getConnection((err, connection) => {
if (err) {
    if (err.code === 'PROTOCOL_CONNECTION_LOST') {
        console.error('Database connection was closed.')
    }
    if (err.code === 'ER_CON_COUNT_ERROR') {
        console.error('Database has too many connections.')
    }
    if (err.code === 'ECONNREFUSED') {
        console.error('Database connection was refused.')
    }
}
if (connection) connection.release()
 return
 })
// Promisify for Node.js async/await.
 pool.query = util.promisify(pool.query)

 module.exports = pool

必须将节点 -v> 8.x 升级

您必须使用异步函数才能使用 await。

例：

   var pool = require('./database')
  // node -v must > 8.x, --> async / await  
  router.get('/:template', async function(req, res, next) 
  {
      ...
    try {
         var _sql_rest_url = 'SELECT * FROM arcgis_viewer.rest_url WHERE id='+ _url_id;
         var rows = await pool.query(_sql_rest_url)
         _url  = rows[0].rest_url // first record, property name is 'rest_url'
         if (_center_lat   == null) {_center_lat = rows[0].center_lat  }
         if (_center_long  == null) {_center_long= rows[0].center_long }
         if (_center_zoom  == null) {_center_zoom= rows[0].center_zoom }          
         _place = rows[0].place

       } catch(err) {
                        throw new Error(err)
       }