Comment puis-je accéder précédente promettent des résultats dans un .alors() de la chaîne?

ECMAScript Harmonie

Bien sûr, ce problème a été reconnu par la langue de designers ainsi. Ils ont fait beaucoup de travail et de la async fonctions de proposition enfin dans

ECMAScript 8

Vous n'avez pas besoin d'un seul then invocation ou une fonction de rappel, comme dans un fonctions asynchrones (qui retourne une promesse lors de l'appelé), vous pouvez tout simplement attendre que les promesses de résoudre directement. Il dispose également d'arbitraire structures de contrôle comme des conditions, des boucles et des try-catch-clauses, mais pour des raisons de commodité, nous n'avons pas besoin d'eux ici:

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

ECMAScript 6

Alors que nous étions en attente pour ES8, nous l'avons déjà fait dans le très même genre de syntaxe. ES6 est venu avec générateur de fonctions, qui permettent de rompre l'exécution à part en morceaux au arbitrairement placé yield mots-clés. Ces tranches peuvent être exécutés les uns après les autres, de façon indépendante, même de manière asynchrone, et c'est exactement ce que nous faisons lorsque nous voulons attendre pour une promesse de résolution avant d'exécuter l'étape suivante.

Il y a consacré des bibliothèques (comme co ou task.js), mais aussi beaucoup de promesse de bibliothèques ont des fonctions d'assistance (Q, Bluebird, lorsque, ...) qui ne cette async étape-par-étape de l'exécution pour vous quand vous leur donnez un générateur de fonction que les rendements des promesses.

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

Ce n'travail dans Node.js depuis la version 4.0, qui est aussi un peu de navigateurs (ou leur dev éditions) ne le support de générateur de syntaxe relativement tôt.

ECMAScript 5

Toutefois, si vous voulez/besoin d'être rétro-compatible vous ne pouvez pas utiliser ceux sans transpiler. À la fois générateur de fonctions et async fonctions sont prises en charge par l'outillage actuel, voir, par exemple, la documentation de Babel sur générateurs et async fonctions.

Et puis, il y a aussi beaucoup d'autres compilation-à-JS langues
qui sont dédiés à l'amélioration de la programmation asynchrone. Généralement, ils utilisent une syntaxe similaire à await, (par exemple,Glacé CoffeeScript), mais il y a aussi d'autres qui disposent d'un Haskell-comme do-notation (par exemple,LatteJs, monadique, PureScript ou LispyScript).

OriginalL'auteur Bergi

De nidification (et), les fermetures

À l'aide de fermetures pour le maintien de la portée des variables (dans notre cas, le succès de rappel des paramètres de fonction) est la solution d'activer JavaScript. Avec des promesses, nous pouvons arbitrairement nid et les aplatir .then() rappels - ils sont sémantiquement équivalents, sauf pour le champ d'application de l'intérieure.

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

Bien sûr, c'est la construction d'une indentation de la pyramide. Si l'indentation est trop grande, vous pouvez toujours appliquer les vieux instruments pour lutter contre la pyramide de doom: modulariser, utiliser des fonctions nommées, et les aplatir la promesse de la chaîne dès que vous n'avez pas besoin d'une variable de plus.

En théorie, vous pouvez toujours éviter de plus de deux niveaux d'imbrication (en faisant toutes les fermetures explicite), dans la pratique, utiliser autant que raisonnable.

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

Vous pouvez également utiliser des fonctions d'assistance pour ce genre de l'application partielle, comme _.partial de Trait de soulignement/lodash ou la natif .bind() méthode, de diminuer encore l'indentation:

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
}

OriginalL'auteur Bergi

Mutable contextuel de l'état

Le trivial (mais peu élégante et plutôt susceptible de causer des erreurs) la solution est d'utiliser le plus-portée des variables (à laquelle tous les rappels dans la chaîne d'accès) et d'écrire des valeurs de résultat à eux quand vous les obtenez:

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

Au lieu de beaucoup de variables, on peut également utiliser un (initialement vide) de l'objet, sur lequel les résultats sont stockés en tant que de créer dynamiquement des propriétés.

Cette solution présente plusieurs inconvénients:

• Mutable état est laid, et les variables globales sont mal.
• Ce modèle ne fonctionne pas sur la fonction de limites, modularising les fonctions est plus difficile que leurs déclarations ne doit pas quitter l'étendue partagée
• La portée des variables n'empêche pas d'y accéder avant ils sont initialisés. C'est particulièrement vrai pour les complexes promesse de constructions (boucles, les branchements, les excptions) où les conditions de course qui pourrait arriver. En passant de l'état explicitement, une déclaratif de conception qui promet d'encourager, de forces plus propre style de codage qui peut l'en empêcher.
• On doit choisir la portée de ces variables partagées correctement. Il doit être exécutée la fonction pour empêcher les conditions de compétition entre les parallèles multiples invocations, comme ce serait le cas si, par exemple, l'état est stocké sur une instance.

Le Bluebird bibliothèque encourage l'utilisation d'un objet qui est transmis le long, en utilisant leur bind() méthode pour affecter un objet de contexte à une promesse de la chaîne. Il sera accessible à partir de chaque fonction de rappel via le inutilisable this mot clé. Tandis que les propriétés de l'objet sont plus enclins à inaperçue fautes de frappe que sur des variables, le modèle est assez astucieux:

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
}

Cette approche peut être facilement simulé dans la promesse des bibliothèques qui ne prennent pas en charge .bind (bien que de façon un peu plus verbeux et ne peut pas être utilisée dans une expression):

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

OriginalL'auteur Bergi

Nœud 7.4 prend désormais en charge async/await appels avec l'harmonie du pavillon.

Essayez ceci:

async function getExample(){

  let response = await returnPromise();

  let response2 = await returnPromise2();

  console.log(response, response2)

}

getExample()

et exécutez le fichier avec:

node --harmony-async-await getExample.js

Simple que peut l'être!

OriginalL'auteur Antoine

À ce jours, j'ai aussi hava répondre à certaines questions comme vous. Enfin, j'ai trouvé une bonne solution avec les quesition, c'est simple et bon à lire. J'espère que cela peut vous aider.

Selon comment-à-chaîne-javascript-promesses

ok, regardons le 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);
    });

OriginalL'auteur yzfdjzwl

Lors de l'utilisation de bluebird, vous pouvez utiliser .bind méthode pour partager des variables dans la promesse de la chaîne:

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

veuillez consulter ce lien pour plus d'informations:

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

OriginalL'auteur alphakevin

Je pense que vous pouvez utiliser hachage de RSVP.

Quelque chose comme ci-dessous :

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

OriginalL'auteur Vishu