comment briser la chaîne de promesses

Je une promesse dans un tel mode,

function getMode(){
    var deferred = Promise.defer();

    checkIf('A')
    .then(function(bool){
        if(bool){
            deferred.resolve('A');
        }else{
            return checkIf('B');
        }
    }).then(function(bool){
        if(bool){
            deferred.resolve('B');
        }else{
            return checkIf('C');
        }
    }).then(function(bool){
        if(bool){
            deferred.resolve('C');
        }else{
            deferred.reject();
        }
    });

    return deferred.promise;
}

checkIf retourne une promesse, et oui checkIf ne peut pas être modifié.

Comment puis-je sortir de la chaîne lors du premier match? (toute autre manière que celle explicitement jeter erreur?)

source d'informationauteur mido

  1. 3

    Je pense que vous ne voulez pas d'une chaîne. Dans un mode synchrone, vous auriez écrit

    function getMode(){
    if (checkIf('A')) {
        return 'A';
    } else {
        if (checkIf('B')) {
            return 'B';
        } else {
            if (checkIf('C')) {
                return 'C';
            } else {
                throw new Error();
            }
        }
    }
}

    et c'est comment il devrait être traduit de promesses:

    function getMode(){
    checkIf('A').then(function(bool) {
        if (bool)
            return 'A';
        return checkIf('B').then(function(bool) {
            if (bool)
                return 'B';
            return checkIf('C').then(function(bool) {
                if (bool)
                    return 'C';
                throw new Error();
            });
        });
    });
}

    Il n'y a pas de if else-aplatissement de promesses.

  2. 11

    Toute autre manière que celle explicitement jeter erreur?

    Vous pouvez avoir besoin de jeter quelque chose, mais il n'a pas à être une erreur.

    La plupart promesse implémentations des méthodes catch accepter le premier argument comme type d'erreur (mais pas tous, et pas ES6 promesse), il serait utile dans cette situation:

    function BreakSignal() { }

getPromise()
    .then(function () {
        throw new BreakSignal();
    })
    .then(function () {
        //Something to skip.
    })
    .catch(BreakSignal, function () { })
    .then(function () {
        //Continue with other works.
    });

    - Je ajouter de la capacité à briser dans la mise en œuvre récente de ma propre promesse de la bibliothèque. Et si vous utilisiez ThenFail (comme vous le feriez probablement pas), vous pouvez écrire quelque chose comme ceci:

    getPromise()
    .then(function () {
        Promise.break;
    })
    .then(function () {
        //Something to skip.
    })
    .enclose()
    .then(function () {
        //Continue with other works.
    });
  3. 3

    Je voudrais juste utiliser coroutines/fraiece qui conduit à beaucoup plus simple de code:

    function* getMode(){
    if(yield checkIf('A'))
        return 'A';
    if(yield checkIf('B'))
        return 'B';
    if(yield checkIf('C'))
        return 'C';
    throw undefined; //don't actually throw or reject with non `Error`s in production
}

    Si vous n'avez pas de générateurs puis, il y a toujours traceur ou 6to5.

  4. 3

    Vous pouvez utiliser
    return { then: function() {} };

    .then(function(bool){
    if(bool){
        deferred.resolve('A');
        return { then: function() {} }; //end/break the chain
    }else{
        return checkIf('B');
    }
})

    L'instruction return renvoie une "mesure", seulement, que la méthode ne fait rien.
    Lorsqu'il est retourné à partir d'une fonction à l'époque(), alors() va essayer d'obtenir le résultat de la thenable.
    La mesure de l' "puis" prend un rappel, mais qui ne sera jamais appelé dans ce cas. Ainsi, le "puis()" retourne, et le rappel pour le reste de la chaîne ne se produise pas.

  5. 0

    j'aime beaucoup les réponses postées jusqu'à présent que d'atténuer ce que le q readme appelle la "pyramide de la mort". pour l'amour de la discussion, je vais ajouter le modèle que j'ai plantaient avant de chercher autour pour voir ce que les autres font. j'ai écrit une fonction comme

    var null_wrap = function (fn) {
  return function () {
    var i;
    for (i = 0; i < arguments.length; i += 1) {
      if (arguments[i] === null) {
        return null;
      }
    }
    return fn.apply(null, arguments);
  };
};

    et j'ai fait quelque chose de totalement analogue à @vilicvane réponse, à l'exception plutôt que throw new BreakSignal()j'avais écrit return nullet enveloppé de tous les .then rappels dans null_wrap comme

    then(null_wrap(function (res) { /* do things */ }))

    je pense que c'est une bonne réponse b/c il évite beaucoup d'indentation et b/c, l'OP a demandé spécifiquement pour une solution qui n'est pas throw. cela dit, je peut revenir en arrière et utiliser quelque chose de plus comme ce que @vilicvane n'b/c, certains de la bibliothèque de promesses pourrait revenir null pour indiquer autre chose que de "briser la chaîne", et qui pourrait être source de confusion.

    c'est plus un appel pour plus de commentaires/réponses que "c'est certainement la façon de le faire" réponse.

  6. 0

    Venant probablement la fin de la partie ici, mais j'ai récemment posté une réponse à l'aide de générateurs et de la co bibliothèque qui permettrait de répondre à cette question (voir la solution 2):

    Le code serait quelque chose comme:

    const requestHandler = function*() {

        const survey = yield Survey.findOne({
            _id: "bananasId"
        });

        if (survey !== null) {
            console.log("use HTTP PUT instead!");
            return;
        }

        try {
            //saving empty object for demonstration purposes
            yield(new Survey({}).save());
            console.log("Saved Successfully !");
            return;
        }
        catch (error) {
            console.log(`Failed to save with error:  ${error}`);
            return;
        }

    };

    co(requestHandler)
        .then(() => {
            console.log("finished!");
        })
        .catch(console.log);

    Vous serait assez bien écrire du code synchrone qui serait en réalité asynchrone !

    Espère que cela aide!