Rupture de la promesse et de la chaîne d'appeler une fonction sur la base de l'étape dans la chaîne où il est cassé (rejeté)

La raison que votre code ne fonctionne pas comme prévu, c'est qu'il est en train de faire quelque chose de différent de ce que vous pensez que cela fonctionne.

Disons que vous avez quelque chose comme ce qui suit:

stepOne()
.then(stepTwo, handleErrorOne)
.then(stepThree, handleErrorTwo)
.then(null, handleErrorThree);

Afin de mieux comprendre ce qui se passe, faisons semblant de croire que c'est du code synchrone avec try/catch blocs:

try {
    try {
        try {
            var a = stepOne();
        } catch(e1) {
            a = handleErrorOne(e1);
        }
        var b = stepTwo(a);
    } catch(e2) {
        b = handleErrorTwo(e2);
    }
    var c = stepThree(b);
} catch(e3) {
    c = handleErrorThree(e3);
}

La onRejected gestionnaire (le deuxième argument de then) est essentiellement un mécanisme de correction des erreurs (comme un catch bloc). Si une erreur est renvoyée dans handleErrorOne, il sera pris par le prochain bloc catch (catch(e2)), et ainsi de suite.

Ce n'est évidemment pas ce que vous souhaitiez.

Disons que nous voulons que l'ensemble de la résolution de la chaîne échoué, peu importe ce qui va mal:

stepOne()
.then(function(a) {
    return stepTwo(a).then(null, handleErrorTwo);
}, handleErrorOne)
.then(function(b) {
    return stepThree(b).then(null, handleErrorThree);
});

Remarque: Nous ne pouvons laisser la handleErrorOne où il est, car il va seulement être invoquée si stepOne rejette (c'est la première fonction de la chaîne, de sorte que nous savons que si la chaîne est rejetée à ce stade, il ne peut être en raison de cette fonction de la promesse).

Le changement important est que les gestionnaires d'erreur pour les autres fonctions ne font pas partie de la principale promesse de la chaîne. Au lieu de cela, chaque étape a son propre "sous-chaîne" avec un onRejected qui n'est appelée que si l'étape a été rejetée (mais ne peut pas être atteint par la chaîne principale directement).

La raison pour laquelle cela fonctionne est que les deux onFulfilled et onRejected sont des arguments facultatifs à la then méthode. Si une promesse est remplie (c'est à dire résolu) et la prochaine then dans la chaîne n'ont pas de onFulfilled gestionnaire, la chaîne continuera jusqu'à ce qu'il y en a un avec un gestionnaire.

Cela signifie que les deux lignes suivantes sont équivalentes:

stepOne().then(stepTwo, handleErrorOne)
stepOne().then(null, handleErrorOne).then(stepTwo)

Mais la ligne suivante est pas équivalent aux deux ci-dessus:

stepOne().then(stepTwo).then(null, handleErrorOne)

Angulaire de la promesse de la bibliothèque $q est basé sur kriskowal de Q de la bibliothèque (qui est plus riche de l'API, mais il contient tout ce que vous pouvez trouver dans $q). Q Les docs de l'API sur GitHub pourrait s'avérer utile. Q implémente l' Promesses/A+ caractéristiques, qui va dans le détail sur la façon dont then et la promesse de résolution de comportement fonctionne exactement.

EDIT:

Aussi garder à l'esprit que si vous voulez sortir de la chaîne dans votre gestionnaire d'erreur, il doit retourner le refus de la promesse ou de jeter une Erreur (qui sera pris et enveloppé dans le refus de la promesse automatiquement). Si vous ne rentrez pas une promesse, then encapsule la valeur de retour dans la résolution de la promesse de vous.

Cela signifie que si vous ne retourne rien, vous êtes effectivement en retour d'un résolus promesse pour la valeur undefined.

Ce que vous avez besoin est une répétition de .then() de la chaîne avec un cas particulier pour commencer et un cas particulier à la fin.

Le truc est d'obtenir le numéro de l'étape de la cas d'échec à l'ondulation grâce à un final gestionnaire d'erreur.

• Début: appel step(1) sans condition.
• Motif répété: la chaîne a .then() avec les rappels suivants:
  • succès: appel de l'étape(n+1)
  • échec: jeter la valeur à laquelle la précédente deferered a été rejetée ou renvoyer l'erreur.
• Finale: chaîne .then() sans succès, de gestionnaire et de gestionnaire d'erreur.

Vous pouvez écrire toute chose dans la main, mais il est plus facile de démontrer le modèle nommés, généralisées de fonctions :

function nextStep(n) {
    return step(n + 1);
}

function step(n) {
    console.log('step ' + n);
    var deferred = $q.defer();
    (n === 3) ? deferred.reject(n) : deferred.resolve(n);
    return deferred.promise;
}

function stepError(n) {
    throw(n);
}

function finalError(n) {
    console.log('finalError ' + n);
}
step(1)
    .then(nextStep, stepError)
    .then(nextStep, stepError)
    .then(nextStep, stepError)
    .then(nextStep, stepError)
    .then(nextStep, stepError)
    .then(null, finalError);});

voir démo

Noter comment, dans step(), le différé est rejetée ou résolus avec n, rendant ainsi que la valeur à la disposition des rappels dans la prochaine .then() dans la chaîne. Une fois stepError est appelée, l'erreur est relancés à plusieurs reprises jusqu'à ce qu'il soit traité par finalError.

Si je comprends bien, vous voulez seulement l'erreur en cas d'échec à l'étape de montrer, non?

Qui devrait être aussi simple que de changer le cas d'échec de la première promesse:

step(1).then(function (response) {
step(2);
}, function (response) {
stepError(1);
return response;
}).then( ... )

En retournant $q.reject() dans la première étape du cas d'échec, vous êtes en rejetant cette promesse, ce qui provoque la errorCallback d'être appelé dans le 2ème then(...).

Si vous voulez résoudre ce problème en utilisant async/await:

(async function(){    
try {        
const response1, response2, response3
response1 = await promise1()
if(response1){
response2 = await promise2()
}
if(response2){
response3 = await promise3()
}
return [response1, response2, response3]
} catch (error) {
return []
}
})()

Trouvé Promesse.le prototype.catch() exemples sur MDN ci-dessous très utile.

(La accepté de répondre mentionne then(null, onErrorHandler) qui est fondamentalement la même que catch(onErrorHandler).)

En utilisant et en enchaînant les prises méthode

var p1 = new Promise(function(resolve, reject) {
resolve('Success');
});
p1.then(function(value) {
console.log(value); //"Success!"
throw 'oh, no!';
}).catch(function(e) {
console.log(e); //"oh, no!"
}).then(function(){
console.log('after a catch the chain is restored');
}, function () {
console.log('Not fired due to the catch');
});
//The following behaves the same as above
p1.then(function(value) {
console.log(value); //"Success!"
return Promise.reject('oh, no!');
}).catch(function(e) {
console.log(e); //"oh, no!"
}).then(function(){
console.log('after a catch the chain is restored');
}, function () {
console.log('Not fired due to the catch');
});

Pièges en lançant des erreurs

//Throwing an error will call the catch method most of the time
var p1 = new Promise(function(resolve, reject) {
throw 'Uh-oh!';
});
p1.catch(function(e) {
console.log(e); //"Uh-oh!"
});
//Errors thrown inside asynchronous functions will act like uncaught errors
var p2 = new Promise(function(resolve, reject) {
setTimeout(function() {
throw 'Uncaught Exception!';
}, 1000);
});
p2.catch(function(e) {
console.log(e); //This is never called
});
//Errors thrown after resolve is called will be silenced
var p3 = new Promise(function(resolve, reject) {
resolve();
throw 'Silenced Exception!';
});
p3.catch(function(e) {
console.log(e); //This is never called
});

S'il est résolu

//Create a promise which would not call onReject
var p1 = Promise.resolve("calling next");
var p2 = p1.catch(function (reason) {
//This is never called
console.log("catch p1!");
console.log(reason);
});
p2.then(function (value) {
console.log("next promise's onFulfilled"); /* next promise's onFulfilled */
console.log(value); /* calling next */
}, function (reason) {
console.log("next promise's onRejected");
console.log(reason);
});

Essayer ro utiliser comme libs:

https://www.npmjs.com/package/promise-chain-break

    db.getData()
.then(pb((data) => {
if (!data.someCheck()) {
tellSomeone();
//All other '.then' calls will be skiped
return pb.BREAK;
}
}))
.then(pb(() => {
}))
.then(pb(() => {
}))
.catch((error) => {
console.error(error);
});