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

您可以在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（）。

es6 promisify将基于回调的函数转换为基于Promise的函数。

const promisify = require('es6-promisify');

const promisedFn = promisify(callbackedFn, args);

裁判：https://www.npmjs.com/package/es6-promisify

kriskowal的Q库包含对promise函数的回调。这样的方法：

obj.prototype.dosomething(params, cb) {
  ...blah blah...
  cb(error, results);
}

可以使用Q.invoke进行转换

Q.ninvoke(obj,"dosomething",params).
then(function(results) {
});

使用普通的javaScript，这里有一个承诺api回调的解决方案。

function get(url, callback) {
        var xhr = new XMLHttpRequest();
        xhr.open('get', url);
        xhr.addEventListener('readystatechange', function () {
            if (xhr.readyState === 4) {
                if (xhr.status === 200) {
                    console.log('successful ... should call callback ... ');
                    callback(null, JSON.parse(xhr.responseText));
                } else {
                    console.log('error ... callback with error data ... ');
                    callback(xhr, null);
                }
            }
        });
        xhr.send();
    }

/**
     * @function promisify: convert api based callbacks to promises
     * @description takes in a factory function and promisifies it
     * @params {function} input function to promisify
     * @params {array} an array of inputs to the function to be promisified
     * @return {function} promisified function
     * */
    function promisify(fn) {
        return function () {
            var args = Array.prototype.slice.call(arguments);
            return new Promise(function(resolve, reject) {
                fn.apply(null, args.concat(function (err, result) {
                    if (err) reject(err);
                    else resolve(result);
                }));
            });
        }
    }

var get_promisified = promisify(get);
var promise = get_promisified('some_url');
promise.then(function (data) {
        // corresponds to the resolve function
        console.log('successful operation: ', data);
}, function (error) {
        console.log(error);
});

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

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