Wie erhalte ich Zugang zu früheren Versprechen, die Ergebnisse in eine .dann() Kette?

ECMAScript Harmony

Natürlich, dieses problem wurde erkannt, die durch die Sprache-Designern sowie. Sie hat eine Menge Arbeit, und die async-Funktionen Vorschlag schaffte es endlich in

ECMAScript 8

Brauchen Sie nicht einen einzigen then Aufruf oder die callback-Funktion nicht mehr, wie in einem asynchronen Funktion (, die eine Zusage zurückgibt, wenn Sie aufgerufen wird), können Sie einfach warten, für verspricht zu lösen direkt. Es verfügt auch über beliebige Kontrollstrukturen wie Bedingungen, Schleifen und try-catch-Klauseln, aber für die Bequemlichkeit, die wir nicht brauchen Sie hier:

async function getExample() {
    var resultA = await promiseA(…);
    //some processing
    var resultB = await promiseB(…);
    //more processing
    return //something using both resultA and resultB
}

ECMAScript 6

Während wir warteten, ES8, das haben wir schon getan verwenden eine sehr ähnliche syntax. ES6 kam mit generator-Funktionen, mit denen zu brechen, die die Ausführung auseinander in Stücke zu willkürlich platziert yield keywords. Diese Scheiben können ausgeführt werden, nachdem jeder andere, unabhängig voneinander, sogar asynchron - und das ist genau das, was wir tun, wenn wir warten wollen für ein Versprechen, Auflösung, bevor Sie den nächsten Schritt.

Gibt es engagierte Bibliotheken (wie co oder task.js), aber auch viele Versprechen Bibliotheken haben Hilfsfunktionen ( Q , Bluebird, wenn, ...), die das async-Schritt-für-Schritt-Ausführung für Sie, wenn Sie geben Sie eine generator-Funktion, die Erträge verspricht.

var getExample = Promise.coroutine(function* () {
//              ^^^^^^^^^^^^^^^^^ Bluebird syntax
    var resultA = yield promiseA(…);
    //some processing
    var resultB = yield promiseB(…);
    //more processing
    return //something using both resultA and resultB
});

Dies hat nicht immer funktioniert Node.js seit der version 4.0, auch ein paar Browser (oder deren dev-Editionen) unterstützt hat, generator-syntax relativ früh.

ECMAScript 5

Jedoch, wenn Sie wollen/müssen, werden rückwärts-kompatibel, Sie können nicht verwenden, die ohne einen transpiler. Beide generator-Funktionen und async-Funktionen werden unterstützt, indem die aktuellen Werkzeuge finden Sie zum Beispiel in der Dokumentation von Babel auf Generatoren und async-Funktionen.

Und dann gibt es auch viele andere compile -, um-JS Sprachen
speziell zur Lockerung der asynchronen Programmierung. Sie in der Regel verwenden Sie eine syntax wie die await (z.B. Iced CoffeeScript), aber es gibt auch andere, die über ein Haskell-wie do-notation (z.B. LatteJs, der monadischen, PureScript oder LispyScript).

InformationsquelleAutor Bergi

Verschachteln (und) Verschlüsse

Verwendung von Verschlüssen für die Aufrechterhaltung der Gültigkeitsbereich von Variablen (in unserem Fall, die Erfolgs-callback-Funktion Parameter) ist die Natürliche JavaScript-Lösung. Mit dem Versprechen, wir können beliebig nest und glätten .then() Rückrufe - Sie sind semantisch äquivalent, mit der Ausnahme für den Anwendungsbereich der inneren.

function getExample() {
    return promiseA(…).then(function(resultA) {
        //some processing
        return promiseB(…).then(function(resultB) {
            //more processing
            return //something using both resultA and resultB;
        });
    });
}

Natürlich ist das Gebäude eine Einbuchtung der Pyramide. Wenn die Einrückung ist immer zu groß, können Sie immer noch gelten die alten Werkzeuge, die gegen die pyramid of doom: Modularisieren, mit extra benannten Funktionen, und glätten Sie das Versprechen Kette, sobald Sie brauchen nicht eine variable mehr.

In der Theorie kann man immer vermeiden, mehr als zwei Ebenen der Verschachtelung, indem alle Sperrungen explizit), in der Praxis möglichst viele so vernünftig sind.

function getExample() {
    //preprocessing
    return promiseA(…).then(makeAhandler(…));
}
function makeAhandler(…)
    return function(resultA) {
        //some processing
        return promiseB(…).then(makeBhandler(resultA, …));
    };
}
function makeBhandler(resultA, …) {
    return function(resultB) {
        //more processing
        return //anything that uses the variables in scope
    };
}

Können Sie auch die Hilfsfunktionen für diese Art von partielle Anwendung, wie _.partial aus Unterstreichen/lodash oder die native .bind() Methode, weiter zu verringern Einzug:

function getExample() {
    //preprocessing
    return promiseA(…).then(handlerA);
}
function handlerA(resultA) {
    //some processing
    return promiseB(…).then(handlerB.bind(null, resultA));
}
function handlerB(resultA, resultB) {
    //more processing
    return //anything that uses resultA and resultB
}

InformationsquelleAutor Bergi

Veränderlich kontextuellen Zustand

Dem trivialen (aber unelegant und eher fehlerträchtig) Lösung ist, nur eine höhere-Geltungsbereich von Variablen (zu denen alle Rückrufe in der Kette Zugriff haben) und schreiben Sie das Ergebnis Werten Sie diese, wenn Sie Sie bekommen:

function getExample() {
    var resultA;
    return promiseA(…).then(function(_resultA) {
        resultA = _resultA;
        //some processing
        return promiseB(…);
    }).then(function(resultB) {
        //more processing
        return //something using both resultA and resultB
    });
}

Statt vieler Variablen könnte man auch ein (zunächst noch leeres) Objekt, auf dem die Ergebnisse gespeichert werden als dynamisch erzeugte Eigenschaften.

Diese Lösung hat mehrere Nachteile:

• Änderbarer Zustand ist hässlich, und Globale Variablen sind böse.
• Dieses Muster nicht funktioniert über die Funktion von Grenzen, die Modularisierung der Funktionen wird immer schwieriger, da sich Ihre Erklärungen müssen nicht aus dem freigegebenen Bereich
• Den Bereich der Variablen nicht verhindern, dass der Zugang zu Ihnen, bevor Sie initialisiert werden. Dies ist besonders wahrscheinlich für komplexe Versprechen Konstruktionen (Schleifen, Verzweigungen, excptions), wo race conditions auftreten. Die Weitergabe ausdrücklich ein deklarative design verspricht ermutigen, Kräfte ein sauberer Programmierstil, die diese verhindern können.
• Muss man wählen, den Rahmen für die gemeinsamen Variablen richtig. Es muss sich lokal auf die ausgeführte Funktion zur Vermeidung von race-conditions zwischen mehreren parallelen aufrufen, als wäre der Fall, wenn, zum Beispiel, Zustand gespeichert wurde, auf eine Instanz.

Bluebird Bibliothek fördert die Nutzung der ein Objekt übergeben wird, zusammen mit Ihre bind() Methode ein kontextobjekt zuweisen, um ein Versprechen Kette. Es wird im Internet von jeder callback-Funktion, die über die sonst unbrauchbar this - Schlüsselwort. Während Objekt-Eigenschaften sind mehr anfällig für unbemerkte Tippfehler als Variablen, das Muster ist Recht clever:

function getExample() {
    return promiseA(…)
    .bind({}) //Bluebird only!
    .then(function(resultA) {
        this.resultA = resultA;
        //some processing
        return promiseB(…);
    }).then(function(resultB) {
        //more processing
        return //something using both this.resultA and resultB
    }).bind(); //don't forget to unbind the object if you don't want the
               //caller to access it
}

Dieser Ansatz kann leicht simuliert Versprechen Bibliotheken nicht unterstützen .binden (obwohl in einer etwas ausführlicheren Art und Weise und kann nicht in einem Ausdruck verwendet werden):

function getExample() {
    var ctx = {};
    return promiseA(…)
    .then(function(resultA) {
        this.resultA = resultA;
        //some processing
        return promiseB(…);
    }.bind(ctx)).then(function(resultB) {
        //more processing
        return //something using both this.resultA and resultB
    }.bind(ctx));
}

InformationsquelleAutor Bergi

Knoten 7.4 unterstützt nun async/await-Anrufe mit den Eintracht-fahne.

Versuchen Sie dies:

async function getExample(){

  let response = await returnPromise();

  let response2 = await returnPromise2();

  console.log(response, response2)

}

getExample()

und führen Sie die Datei mit:

node --harmony-async-await getExample.js

Einfach, wie sein kann!

InformationsquelleAutor Antoine

Dieser Tage, die ich auch hava treffen sich einige Fragen wie Sie. Endlich finde ich eine gute Lösung mit der quesition, es ist einfach und gut zu Lesen. Ich hoffe, dass diese Ihnen helfen können.

Laut how-to-chain-javascript-promises

ok, schauen wir uns den code:

const firstPromise = () => {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            console.log('first promise is completed');
            resolve({data: '123'});
        }, 2000);
    });
};

const secondPromise = (someStuff) => {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            console.log('second promise is completed');
            resolve({newData: `${someStuff.data} some more data`});
        }, 2000);
    });
};

const thirdPromise = (someStuff) => {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            console.log('third promise is completed');
            resolve({result: someStuff});
        }, 2000);
    });
};

firstPromise()
    .then(secondPromise)
    .then(thirdPromise)
    .then(data => {
        console.log(data);
    });

InformationsquelleAutor yzfdjzwl

Bei der Verwendung von bluebird, die Sie verwenden können .bind Methode zum freigeben von Variablen in Versprechen Kette:

somethingAsync().bind({})
.spread(function (aValue, bValue) {
    this.aValue = aValue;
    this.bValue = bValue;
    return somethingElseAsync(aValue, bValue);
})
.then(function (cValue) {
    return this.aValue + this.bValue + cValue;
});

bitte überprüfen Sie diesen link für weitere Informationen:

http://bluebirdjs.com/docs/api/promise.bind.html

InformationsquelleAutor alphakevin

Ich denke, dass Sie verwenden können, hash von RSVP.

Etwas wie die folgenden :

    const mainPromise = () => {
        const promise1 = new Promise((resolve, reject) => {
            setTimeout(() => {
                console.log('first promise is completed');
                resolve({data: '123'});
            }, 2000);
        });

        const promise2 = new Promise((resolve, reject) => {
            setTimeout(() => {
                console.log('second promise is completed');
                resolve({data: '456'});
            }, 2000);
        });

        return new RSVP.hash({
              prom1: promise1,
              prom2: promise2
          });

    };


   mainPromise()
    .then(data => {
        console.log(data.prom1);
        console.log(data.prom2);
    });

InformationsquelleAutor Vishu