Quand est .ensuite(réussite, échec) considéré comme un antipattern pour des promesses?

Quelle est la différence?

La .then() appel renvoie une promesse qui sera rejetée dans le cas où la fonction de rappel renvoie une erreur. Cela signifie que, lorsque votre succès logger échoue, l'erreur serait passé à la suite de .catch() de rappel, mais pas à la fail rappel qui va de pair avec success.

Voici un flux de contrôle diagramme:

De l'exprimer dans le code synchrone:

//some_promise_call().then(logger.log, logger.log)
then: {
    try {
        var results = some_call();
    } catch(e) {
        logger.log(e);
        break then;
    } //else
        logger.log(results);
}

La deuxième log (qui est comme le premier argument de .then()) seront exécutées uniquement dans le cas où aucune exception s'est produite. L'étiquette de bloc et les break déclaration sentir un peu bizarre, c'est effectivement ce que python a essayez-sauf-else pour (lecture recommandée!).

//some_promise_call().then(logger.log).catch(logger.log)
try {
    var results = some_call();
    logger.log(results);
} catch(e) {
    logger.log(e);
}

La catch enregistreur permettra également de gérer les exceptions de la réussite enregistreur d'appel.

Tellement la différence.

Je n'ai pas très bien compris son explication pour le try et catch

L'argument est que, en général, vous voulez rattraper les erreurs à chaque étape du traitement, et que vous ne devriez pas l'utiliser dans les chaînes. L'espoir est que vous n'avez qu'une finale gestionnaire qui s'occupe de toutes les erreurs - tout, lorsque vous utilisez le "antipattern", des erreurs dans certains de les rappels ne sont pas traitées.

Cependant, ce modèle est en fait très utile: Quand vous voulez pour gérer les erreurs qui s'est passé exactement de cette étape, et vous voulez faire quelque chose entièrement différentes lorsque aucune erreur ne s'est passé - c'est à dire lorsque l'erreur est irrécupérable. Être conscient que c'est ramification votre flux de contrôle. Bien sûr, c'est parfois souhaitée.

---

Quel est le problème avec ce la suite?

some_promise_call()
.then(function(res) { logger.log(res) }, function(err) { logger.log(err) })

Que vous avez dû vous répéter votre rappel. Vous avez plutôt envie

some_promise_call()
   .catch(function(e) {
       return e; //it's OK, we'll just log it
   })
   .done(function(res) {
       logger.log(res);
   });

Vous aussi pourriez envisager d'utiliser .enfin() pour cela.

En regardant les avantages et les inconvénients de les deux, nous pouvons faire un calcul de prédiction de ce qui est approprié pour la situation.
Ce sont les deux principales approches pour la mise en œuvre de promesses. Les deux ont il est des plus et des moins

Attraper Approche

some_promise_call()
.then(function(res) { logger.log(res) })
.catch(function(err) { logger.log(err) })

Avantages

1. Toutes les erreurs sont traitées par un bloc catch.
2. Même captures aucune exception dans le bloc.
3. Chaînage de plusieurs succès rappels

Inconvénients

1. En cas de chaînage, il devient difficile de montrer les différents messages d'erreur.

De Succès Ou D'Erreur D'Approche

some_promise_call()
.then(function success(res) { logger.log(res) },
      function error(err) { logger.log(err) })

Avantages

1. Vous obtenez un grain de contrôle d'erreur.
2. Vous pouvez avoir des erreur commune qui gère la fonction de diverses catégories d'erreurs comme db erreur, erreur 500, etc.

Disavantages

1. Vous aurez toujours besoin d'un autre catch si vous souhaitez gestionnaire d'erreurs lancé par le succès de rappel

À l'aide de .then().catch() vous permet d'activer Promesse de Chaînage qui est nécessaire à l'exécution d'un flux de travail. Vous pourriez en avoir besoin de certaines informations de base de données, alors vous voulez passer à une API asynchrone alors vous voulez manipuler la réponse. Vous pouvez pousser la réponse dans la base de données. La manipulation de tous ces flux de travail avec votre concept, c'est faisable mais très dur à gérer. La meilleure solution sera then().then().then().then().catch() qui reçoit toutes les erreurs en une seule fois attraper et vous permet de garder la maintenabilité du code.

À la place des mots, le bon exemple. Code suivant (si la première promesse résolu):

Promise.resolve()
.then
(
  () => { throw new Error('Error occurs'); },
  err => console.log('This error is caught:', err)
);

est identique à:

Promise.resolve()
.catch
(
  err => console.log('This error is caught:', err)
)
.then
(
  () => { throw new Error('Error occurs'); }
)

Mais avec rejetée en première promesse, ce n'est pas identique:

Promise.reject()
.then
(
  () => { throw new Error('Error occurs'); },
  err => console.log('This error is caught:', err)
);

Promise.reject()
.catch
(
  err => console.log('This error is caught:', err)
)
.then
(
  () => { throw new Error('Error occurs'); }
)