由于我们预先知道基于回调的函数的特性，我们可以创建一个函数来转换基于回调的函数转换为返回Promise的等效函数。

回调是函数的最后一个参数如果有错误，它总是传递给回调的第一个参数错误发生后，任何返回值都会传递给回调函数promisify（yourCallbackApi）{返回函数promised（…args）{return new Promise（（resolve，reject）=>{//newArgs=[..args，回调]常量newArgs=[…参数，函数（错误，结果）{if（错误）{返回拒绝（错误）；}解决（结果）；},];//使用新的参数列表调用CallbackApi您的回调Api（…newArgs）；});};}

我的promisify版本的回调函数是P函数：

var P=函数（）{var self=this；var方法=参数[0]；var params=数组.原型.切片.调用（参数，1）；return new Promise（（resolve，reject）=>{if（method&&typeof（method）==“函数”）{params.push（函数（错误，状态）{if（！err）返回解析（状态）否则返回拒绝（err）；});方法.应用（self，params）；}否则返回拒绝（新错误（“不是函数”））；});}var callback=函数（par，回调）{var rnd=数学地板（Math.random（）*2）+1；返回rnd>1？callback（null，par）：回调（new Error（“trap”））；}callback（“callback”，（err，state）=>错误？console.error（错误）：console.log（状态））callback（“callback”，（err，state）=>错误？console.error（错误）：console.log（状态））callback（“callback”，（err，state）=>错误？console.error（错误）：console.log（状态））callback（“callback”，（err，state）=>错误？console.error（错误）：console.log（状态））P（回调，“promise”）.then（v=>console.log（v））.catch（e=>console.error（e））P（回调，“promise”）.then（v=>console.log（v））.catch（e=>console.error（e））P（回调，“promise”）.then（v=>console.log（v））.catch（e=>console.error（e））P（回调，“promise”）.then（v=>console.log（v））.catch（e=>console.error（e））

P函数要求回调签名必须是回调（error，result）。

如果有几个函数需要回调，并且希望它们返回promise，则可以使用此函数进行转换。

function callbackToPromise(func){

    return function(){

        // change this to use what ever promise lib you are using
        // In this case i'm using angular $q that I exposed on a util module

        var defered = util.$q.defer();

        var cb = (val) => {
            defered.resolve(val);
        }

        var args = Array.prototype.slice.call(arguments);
        args.push(cb);    
        func.apply(this, args);

        return defered.promise;
    }
}

Node.js 8.0.0包含一个新的util.provisify（）API，它允许将标准Node.js回调样式的API封装在返回Promise的函数中。下面显示了util.provisify（）的示例用法。

const fs = require('fs');
const util = require('util');

const readFile = util.promisify(fs.readFile);

readFile('/some/file')
  .then((data) => { /* ... */ })
  .catch((err) => { /* ... */ });

请参阅改进对承诺的支持

在Node.js 8中，您可以使用此npm模块动态地promisify对象方法：

https://www.npmjs.com/package/doasync

它使用util.provify和代理，使对象保持不变。Memoization也使用WeakMaps完成）。以下是一些示例：

使用对象：

const fs = require('fs');
const doAsync = require('doasync');

doAsync(fs).readFile('package.json', 'utf8')
  .then(result => {
    console.dir(JSON.parse(result), {colors: true});
  });

具有以下功能：

doAsync(request)('http://www.google.com')
  .then(({body}) => {
    console.log(body);
    // ...
  });

您甚至可以使用本机调用和应用来绑定某些上下文：

doAsync(myFunc).apply(context, params)
  .then(result => { /*...*/ });

在Node.JS中将函数转换为promise之前

var request = require('request'); //http wrapped module

function requestWrapper(url, callback) {
    request.get(url, function (err, response) {
      if (err) {
        callback(err);
      }else{
        callback(null, response);             
      }      
    })
}


requestWrapper(url, function (err, response) {
    console.log(err, response)
})

转换后

var request = require('request');

function requestWrapper(url) {
  return new Promise(function (resolve, reject) { //returning promise
    request.get(url, function (err, response) {
      if (err) {
        reject(err); //promise reject
      }else{
        resolve(response); //promise resolve
      }
    })
  })
}


requestWrapper('http://localhost:8080/promise_request/1').then(function(response){
    console.log(response) //resolve callback(success)
}).catch(function(error){
    console.log(error) //reject callback(failure)
})

如果您需要处理多个请求

var allRequests = [];
allRequests.push(requestWrapper('http://localhost:8080/promise_request/1')) 
allRequests.push(requestWrapper('http://localhost:8080/promise_request/2'))
allRequests.push(requestWrapper('http://localhost:8080/promise_request/5'))    

Promise.all(allRequests).then(function (results) {
  console.log(results);//result will be array which contains each promise response
}).catch(function (err) {
  console.log(err)
});