Wie konvertiere ich eine vorhandene Callback-API in Versprechen?

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 sollte nie werfenzurü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) return reject(err);
             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, die Sie bevorzugen sollten):

function getStuffAsync(param){
    var d = Q.defer();
    getStuff(param,function(err,data){
         if(err !== null) return d.reject(err); //`throw err` also works here.
             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 der Antwort Benjamin Gruenbaum

Ich glaube nicht, dass die window.onload Vorschlag von @Benjamin wird die ganze Zeit arbeiten, da Sie nicht erkennen, ob er aufgerufen wird, nachdem die Last. Ich habe gebissen, dass viele Male. Hier ist eine version, die sollte immer funktionieren:

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

InformationsquelleAutor der Antwort Leo

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 der Antwort Bruno

Node.js 8.0.0 umfasst neue util.promisify() API, mit standard Node.js callback-style APIs verpackt in einer Funktion, die eine Zusage zurückgibt. Ein Beispiel für die Verwendung von util.promisify() ist unten dargestellt.

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

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

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

Sehen Verbesserte Unterstützung für Verspricht

InformationsquelleAutor der Antwort Gian Marco Gherardi

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 der Antwort 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 der Antwort daviddavis

In Node.js 8 Sie können promisify Objekt-Methoden on-the-fly Verwendung dieses npm-Modul:

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

Es nutzt util.promisify und Proxies so, dass Ihr die Objekte unverändert bleiben. Memoization ist auch fertig mit der Verwendung von WeakMaps). Hier sind einige Beispiele:

Mit Objekten:

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

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

Funktionen:

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

Können Sie sogar native call und apply zu binden, etwas Kontext:

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

InformationsquelleAutor der Antwort Do Async

es6-promisify wandelt callback-Funktionen zu Versprechen-basierte Funktionen.

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

const promisedFn = promisify(callbackedFn, args);

Ref: https://www.npmjs.com/package/es6-promisify

InformationsquelleAutor der Antwort Pujan Srivastava