在Node.js 8.0.0的候选版本中，有一个新的实用程序util.profisify（我已经写过util.proficify），它封装了promising任何函数的能力。

它与其他答案中建议的方法没有太大不同，但具有作为核心方法而不需要额外依赖性的优点。

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

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

然后有一个readFile方法，它返回一个本机Promise。

readFile('./notes.txt')
  .then(txt => console.log(txt))
  .catch(...);

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

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

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

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

可以使用Q.invoke进行转换

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

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

我认为@Benjamin的window.onload建议不会一直有效，因为它不会检测加载后是否调用。我已经被那东西咬过很多次了。以下是一个始终有效的版本：

function promiseDOMready() {
    return new Promise(function(resolve) {
        if (document.readyState === "complete") return resolve();
        document.addEventListener("DOMContentLoaded", resolve);
    });
}
promiseDOMready().then(initOnLoad);