Wie konvertiere ich eine vorhandene callback-API verspricht?

Verspricht einen Status haben, beginnen Sie als angemeldet und können abgerechnet werden:

• erfüllt was bedeutet, dass die Berechnung erfolgreich abgeschlossen wurde.
• abgelehnt was bedeutet, dass die Berechnung fehlgeschlagen ist.

Versprechen der Rückkehr Funktionen werfen, zurückkehren sollten Ablehnungen statt. Das werfen von ein Versprechen der Rückkehr-Funktion wird Sie zwingen, ein } catch { und eine .catch. Menschen mit promisified APIs erwarten Sie nicht, Versprechungen zu werfen. Wenn Sie nicht sicher sind, wie Sie asynchrone APIs funktionieren in JS - bitte Lesen Sie diese Antwort ersten.

1. DOM-laden, der eine oder andere Zeit-Ereignis:

So, erstellen verspricht in der Regel bedeutet, dass Sie angeben, wenn Sie sich niederlassen - das bedeutet, dass, wenn Sie sich bewegen, die erfüllt oder zurückgewiesen phase zeigen die Daten zur Verfügung stehen (und kann zugegriffen werden mit .then).

Mit modernen Versprechen Implementierungen unterstützen Promise Konstruktor wie native ES6 promises:

function load() {
    return new Promise(function(resolve, reject) {
        window.onload = resolve;
    });
}

Würden Sie verwenden Sie dann die resultierende Versprechen, wie so:

load().then(function() {
    //Do things after onload
});

Mit Bibliotheken, die Unterstützung der latenten (wir verwenden $q für dieses Beispiel hier, aber wir verwenden auch jQuery später):

function load() {
    var d = $q.defer();
    window.onload = function() { d.resolve(); };
    return d.promise;
}

Oder mit einem jQuery-wie-API hooking auf ein Ereignis geschieht einmal:

function done() {
    var d = $.Deferred();
    $("#myObject").once("click",function() {
        d.resolve();
    });
    return d.promise();
}

2. Plain callback:

Diese APIs sind Recht Häufig, da so gut... Rückrufe sind Häufig in JS. Betrachten wir den Allgemeinen Fall mit onSuccess und onFail:

function getUserData(userId, onLoad, onFail) { …

Mit modernen Versprechen Implementierungen unterstützen Promise Konstruktor wie native ES6 promises:

function getUserDataAsync(userId) {
    return new Promise(function(resolve, reject) {
        getUserData(userId, resolve, reject);
    });
}

Mit Bibliotheken, die Unterstützung der latenten (wir verwenden jQuery für dieses Beispiel hier, aber die haben wir auch benutzt $q oben):

function getUserDataAsync(userId) {
    var d = $.Deferred();
    getUserData(userId, function(res){ d.resolve(res); }, function(err){ d.reject(err); });
    return d.promise();
}

jQuery bietet auch eine $.Deferred(fn) form, das hat den Vorteil, dass Sie uns um eine expression zu schreiben, die emuliert sehr eng an die new Promise(fn) form wie folgt:

function getUserDataAsync(userId) {
    return $.Deferred(function(dfrd) {
        getUserData(userId, dfrd.resolve, dfrd.reject);
    }).promise();
}

Hinweis: Hier nutzen wir die Tatsache, dass ein jQuery deferred s resolve und reject Methoden sind "abnehmbar"; dh. Sie sind verpflichtet, die Instanz jQuery.Latente(). Nicht alle libs die dieses feature bieten.

3. Knoten-Stil callback ("nodeback"):

Knoten Stil Rückrufe (nodebacks) haben ein bestimmtes format, in denen das Rückrufen ist immer das Letzte argument und seine erste parameter ist ein Fehler. Lassen Sie uns zuerst promisify manuell:

getStuff("dataParam", function(err, data) { …

:

function getStuffAsync(param) {
    return new Promise(function(resolve, reject) {
        getStuff(param, function(err, data) {
            if (err !== null) reject(err);
            else resolve(data);
        });
    });
}

Mit deferreds können Sie Folgendes tun (wir verwenden Q für dieses Beispiel, obwohl die Q jetzt unterstützt die neue syntax was Sie bevorzugen sollten):

function getStuffAsync(param) {
    var d = Q.defer();
    getStuff(param, function(err, data) {
        if (err !== null) d.reject(err);
        else d.resolve(data);
    });
    return d.promise;   
}

In der Regel sollten Sie nicht promisify Dinge manuell zu viel, die meisten Versprechen Bibliotheken, die entworfen wurden, mit Knoten im Kopf-als auch native verspricht in Knoten 8+ über eine integrierte Methode für promisifying nodebacks. Zum Beispiel

var getStuffAsync = Promise.promisify(getStuff); //Bluebird
var getStuffAsync = Q.denodeify(getStuff); //Q
var getStuffAsync = util.promisify(getStuff); //Native promises, node only

4. Eine ganze Bibliothek mit Knoten-Stil-Rückrufe:

Gibt es keine goldene Regel hier, Sie promisify Sie eins nach dem anderen. Jedoch, einige Versprechen Implementierungen erlauben Sie, dies zu tun in der Masse, zum Beispiel in Bluebird, Umwandlung einer nodeback-API, um ein Versprechen API ist so einfach wie:

Promise.promisifyAll(API);

Oder mit native verspricht in Knoten:

const { promisify } = require('util');
const promiseAPI = Object.entries(API).map(v => ({key, fn: promisify(v)}))
                         .reduce((o, p) => Object.assign(o, {[p.key]: p.fn}), {});

Hinweise:

• Natürlich, wenn Sie in einer .then - handler, die Sie nicht brauchen, um promisify Dinge. Rückkehr ein Versprechen von einem .then handler zu beheben oder abzulehnen, die Versprechen, den Wert. Das werfen von einem .then handler ist auch eine gute übung und lehnt das Versprechen - das ist das berühmte Versprechen Sicherheit werfen.
• In einer tatsächlichen onload Fall sollten Sie addEventListener eher als onX.

InformationsquelleAutor Benjamin Gruenbaum

Vor der Konvertierung eine Funktion als Versprechen In Node.JS

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

Nach Dem Umwandeln

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

Incase Sie brauchen, um mehrere Anfrage

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

InformationsquelleAutor Sivashanmugam Kannan

Im release candidate für Node.js 8.0.0, es ist ein neues Dienstprogramm, util.promisify (ich habe darüber geschrieben util.promisify), kapselt die Kapazität der promisifying, was Funktion.

Ist es nicht viel anders aus, die Ansätze vorgeschlagen, die in den anderen Antworten, aber hat den Vorteil, dass Sie eine Kern-Methode und benötigt keine zusätzlichen Abhängigkeiten.

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

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

Dann haben Sie eine readFile Methode gibt eine native Promise.

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

InformationsquelleAutor Bruno

Können Sie JavaScript native verspricht mit Node-JS.

Mein Cloud-9-code-link: https://ide.c9.io/adx2803/native-promises-in-node

/**
* Created by dixit-lab on 20/6/16.
*/

var express = require('express');
var request = require('request');   //Simplified HTTP request client.


var app = express();

function promisify(url) {
    return new Promise(function (resolve, reject) {
        request.get(url, function (error, response, body) {
            if (!error && response.statusCode == 200) {
                resolve(body);
            }
            else {
                reject(error);
            }
        })
    });
}

//get all the albums of a user who have posted post 100
app.get('/listAlbums', function (req, res) {
    //get the post with post id 100
    promisify('http://jsonplaceholder.typicode.com/posts/100').then(function (result) {
        var obj = JSON.parse(result);
        return promisify('http://jsonplaceholder.typicode.com/users/' + obj.userId + '/albums')
    })
    .catch(function (e) {
        console.log(e);
    })
    .then(function (result) {
        res.end(result);
    })
})

var server = app.listen(8081, function () {
    var host = server.address().address
    var port = server.address().port

    console.log("Example app listening at http://%s:%s", host, port)
})

//run webservice on browser : http://localhost:8081/listAlbums

InformationsquelleAutor Apoorv

Unter Knoten v7.6+, die eingebaute verspricht und async:

//promisify.js
let promisify = fn => (...args) =>
    new Promise((resolve, reject) =>
        fn(...args, (err, result) => {
            if (err) return reject(err);
            return resolve(result);
        })
    );

module.exports = promisify;

Wie zu verwenden:

let readdir = require('fs').readdir;
let promisify = require('./promisify');
let readdirP = promisify(readdir);

async function myAsyncFn(path) {
    let entries = await readdirP(path);
    return entries;
}

InformationsquelleAutor Paul Spaulding

Mit plain old vanilla javaScript, hier eine Lösung zu promisify eine api-callback.

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

InformationsquelleAutor daviddavis

Können Sie native Versprechen in ES6, zum Beispiel der Umgang mit 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
    });

}

In diesem Beispiel, das Versprechen hat keinen Grund zu scheitern, so reject() wird nie aufgerufen.

InformationsquelleAutor Nicolas Zozol

Können Sie so etwas tun

//@flow

const toPromise = (f: (any) => void) => {
  return new Promise<any>((resolve, reject) => {
    try {
      f((result) => {
        resolve(result)
      })
    } catch (e) {
      reject(e)
    }
  })
}

export default toPromise

Dann verwenden Sie es

async loadData() {
  const friends = await toPromise(FriendsManager.loadFriends)

  console.log(friends)
}

InformationsquelleAutor onmyway133

Es ist wie 5 Jahre zu spät, aber ich wollte den post hier meine promesify version holt Funktionen aus der API callbacks und verwandelt Sie in verspricht

const promesify = fn => {
  return (...params) => ({
    then: cbThen => ({
      catch: cbCatch => {
        fn(...params, cbThen, cbCatch);
      }
    })
  });
};

Werfen Sie einen Blick auf diese sehr einfache version hier:
https://gist.github.com/jdtorregrosas/aeee96dd07558a5d18db1ff02f31e21a

InformationsquelleAutor Julian Torregrosa