Promise Retry Pattern Designs
Modifier
- Motif que continuer à réessayer jusqu'à ce que la promesse est résolu (avec retard et de
maxRetries). - Modèle qui continue à réessayer jusqu'à ce que la condition
rencontre sur le résultat (avec retard et
maxRetries). - Une mémoire efficace Modèle dynamique avec un nombre illimité de tentatives (délai fourni).
Code #1. Continue à réessayer jusqu'à ce que la promesse est résolu (toutes les améliorations de la communauté de la langue etc?)
Promise.retry = function(fn, times, delay) {
return new Promise(function(resolve, reject){
var error;
var attempt = function() {
if (times == 0) {
reject(error);
} else {
fn().then(resolve)
.catch(function(e){
times--;
error = e;
setTimeout(function(){attempt()}, delay);
});
}
};
attempt();
});
};
Utilisation
work.getStatus()
.then(function(result){ //retry, some glitch in the system
return Promise.retry(work.unpublish.bind(work, result), 10, 2000);
})
.then(function(){console.log('done')})
.catch(console.error);
Code #2 garder sur réessayer jusqu'à ce qu'une condition répond sur le then
résultat réutilisables façon (à l'état est ce qui va varier).
work.publish()
.then(function(result){
return new Promise(function(resolve, reject){
var intervalId = setInterval(function(){
work.requestStatus(result).then(function(result2){
switch(result2.status) {
case "progress": break; //do nothing
case "success": clearInterval(intervalId); resolve(result2); break;
case "failure": clearInterval(intervalId); reject(result2); break;
}
}).catch(function(error){clearInterval(intervalId); reject(error)});
}, 1000);
});
})
.then(function(){console.log('done')})
.catch(console.error);
source d'informationauteur user2727195
Vous devez vous connecter pour publier un commentaire.
Quelque chose d'un peu différent ...
Async tentatives peuvent être obtenus par la construction d'une
.catch()
de la chaîne, par opposition à la plus habituelle.then()
de la chaîne.Cette approche est :
Sinon, utilisez une solution récursive.
D'abord, une fonction d'utilité à être utilisé comme un
.catch()
de rappel.Vous pouvez maintenant construire .attraper les chaînes de façon très concise :
1. Réessayer jusqu'à ce que la promesse se résout, avec un délai de
DÉMO: https://jsfiddle.net/duL0qjqe/
2. Réessayer jusqu'à ce que le résultat répond à une certaine condition, sans délai
DÉMO: https://jsfiddle.net/duL0qjqe/1/
3. Réessayer jusqu'à ce que le résultat répond à une certaine condition, avec un délai de
Avoir obtenu votre esprit cycle (1) et (2), un test combiné+delay est tout aussi trivial.
test()
peut être synchrone ou asynchrone.Il serait également facile d'ajouter de nouveaux tests. Tout simplement en sandwich une chaîne de arrêtera entre les deux prises.
DÉMO: https://jsfiddle.net/duL0qjqe/3/
Toutes les versions sont conçues pour
attempt
être une promesse de retour asynchrone en fonction. Il pourrait aussi éventuellement renvoyer une valeur, auquel cas la chaîne de suivre sa voie du succès à la prochaine terminaux/.then()
.2. Modèle qui continue à réessayer jusqu'à ce que la condition répond sur le résultat (avec retard et maxRetries)
C'est une belle façon de faire ce natif de promesses et de façon récursive:
C'est comment vous l'appelez, en supposant que
func
parfois réussit et échoue parfois, renvoie toujours une chaîne de caractères, nous pouvons nous connecter:Ici, nous faisons appel retryOperation lui demandant de réessayer à chaque seconde et avec max retries = 5.
Si vous voulez quelque chose de simple, sans promesses, RxJs serait utile que: https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/retrywhen.md
Une bibliothèque peut le faire facilement : promesse-retry.
Voici quelques exemples pour le tester :
Attendre deuxième tentative réussie :
N'attendent qu'une nouvelle tentative :
Il y a beaucoup de bonnes solutions mentionnées et maintenant avec async/await ces problèmes peuvent être résolus sans trop d'effort.
Si vous n'avez pas l'esprit d'une approche récursive, alors c'est ma solution.