我通常使用的一个简单的泛型函数。

const promisify = (fn, ...args) => {
  return new Promise((resolve, reject) => {
    fn(...args, (err, data) => {
      if (err) {
        return reject(err);
      }
      resolve(data);
    });
  });
};

如何使用它

函数promify接受带有回调的函数：

   const cb = (result) => `The result is ${result}`;

   const sum = (a, b, cb) => {
    const result = a + b;
    cb(result); // passing args to the callback function
   }


  // using the util
  promise = promisify(sum, 3, 1, cb);
  promise.then(x => console.log(x)) // 4

您可能不需要这个答案，但这将有助于了解可用实用程序的内部工作原理

在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 => { /*...*/ });

您可以在ES6中使用本机Promise，例如处理setTimeout：

enqueue(data) {

    const queue = this;
    // returns the Promise
    return new Promise(function (resolve, reject) {
        setTimeout(()=> {
                queue.source.push(data);
                resolve(queue); //call native resolve when finish
            }
            , 10); // resolve() will be called in 10 ms
    });

}

在本例中，Promise没有失败的理由，因此永远不会调用reject（）。

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

请参阅改进对承诺的支持

我的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）。

下面是如何将函数（回调API）转换为promise的实现。

function promisify(functionToExec) {
  return function() {
    var array = Object.values(arguments);
    return new Promise((resolve, reject) => {
      array.push(resolve)
      try {
         functionToExec.apply(null, array);
      } catch (error) {
         reject(error)
      }
    })
  }
}

// USE SCENARIO

function apiFunction (path, callback) { // Not a promise
  // Logic
}

var promisedFunction = promisify(apiFunction);

promisedFunction('path').then(()=>{
  // Receive the result here (callback)
})

// Or use it with await like this
let result = await promisedFunction('path');