Wann wird dann (Erfolg, Misserfolg) als Antipattern für Versprechungen angesehen?

Hatte ich einen Blick auf die bluebird Versprechen FAQin denen es erwähnt, dass .dann(Erfolg, Fehler) ist ein antipattern. Ich verstehe nicht ganz, seine Erklärung für die try und catch.
Was ist daran falsch?

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

Es scheint, das Beispiel ist was die folgenden als dem richtig Weg.

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

Was ist der Unterschied?

InformationsquelleAutor der Frage user2127480 | 2014-07-09

154

Was ist der Unterschied?

Den .then() Aufruf zurück ein Versprechen, das wird abgelehnt, falls der Rückruf wirft einen Fehler. Das bedeutet, wenn sich Ihr Erfolg logger fehlschlägt, wird der Fehler weitergegeben werden, die folgenden .catch() Rückruf, aber nicht auf die fail Rückruf, geht zusammen mit success.

Hier ein Ablaufsteuerung Diagramm:

Auszudrücken synchronous code:
```
//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);
}
```
Zweiten log (das ist wie das erste argument für .then()) wird nur ausgeführt, im Fall, dass keine Ausnahme passiert ist. Den gekennzeichneten block und die break Aussage fühlen sich ein bisschen seltsam, das ist eigentlich das, was python hat try-except-else für (zum Lesen empfohlen!).
```
//some_promise_call().then(logger.log).catch(logger.log)
try {
    var results = some_call();
    logger.log(results);
} catch(e) {
    logger.log(e);
}
```
Den catch logger wird auch die Behandlung von Ausnahmen von dem Erfolg logger-Aufruf.

So viel für die Differenz.

Ich verstehe nicht ganz, seine Erklärung für die try-und catch -

Das argument ist, dass in der Regel Sie möchten, um Fehler abzufangen, in jedem Schritt der Verarbeitung, und dass sollten Sie nicht verwenden es in Ketten. Die Erwartung ist, dass Sie nur noch eine Letzte handler behandelt alle Fehler - während, wenn Sie die "antipattern", Fehler in einigen der damals Rückrufe erfolgen nicht.

Jedoch, dieses Muster ist eigentlich sehr nützlich: Wenn Sie möchten, um Fehler zu behandeln, dass es in genau dieser Schritt, und Sie wollen etwas tun ganz anderewenn kein Fehler passiert ist - also wenn die Fehler nicht behebbarer ist. Bewusst seindass dies Verzweigung Ihre Steuern fließen. Natürlich, dies ist manchmal erwünscht.
Was ist daran falsch?
```
some_promise_call()
.then(function(res) { logger.log(res) }, function(err) { logger.log(err) })
```
Dass Sie wiederholen mussten Ihren Rückruf. Sie wollen lieber
```
some_promise_call()
   .catch(function(e) {
       return e; //it's OK, we'll just log it
   })
   .done(function(res) {
       logger.log(res);
   });
```
Könnten Sie auch erwägen,.endlich().

InformationsquelleAutor der Antwort Bergi
30

Die beiden sind nicht ganz identisch. Der Unterschied ist, dass das erste Beispiel nicht abfangen einer Ausnahme, die ausgelöst wird in Ihrer success handler. Also, wenn Sie Ihre Methode sollte immer nur zurück gelöst verspricht, wie es oft der Fall, müssen Sie einen abschließenden catch - handler (oder noch eine andere then mit einem leeren success parameter). Sicher, es kann sein, dass Ihr then handler tut nichts, die möglicherweise fehlschlagen, in diesem Fall mit einer 2-parameter then könnte in Ordnung sein.

Aber ich glaube, der Punkt, der den text, den Sie verlinkt ist, dass then ist vor allem nützlich gegen Rückrufe ist in seiner Fähigkeit, die an die Kette einer Reihe von asynchronen Schritte, und wenn Sie dieses tatsächlich zu tun, der 2-parameter-form von then subtil verhält sich nicht ganz wie erwartet, aus den oben genannten Gründen. Es ist vor allem widersinnig, wenn verwendet, Mitte der Kette.

Als jemand, der ' s getan, eine Menge von komplexen asynchronen Zeug und stieß in die Ecken wie diese mehr als ich wohl zugeben, dass ich wirklich empfehlen kann, um dieses anti-Muster und gehen mit dem separaten hf-Ansatz.

InformationsquelleAutor der Antwort acjay
13

Durch den Blick auf Vorteile und Nachteile von beiden können wir eine berechnete Vermutung, das ist angemessen für die situation.
Dies sind die zwei wichtigsten Ansätze für die Implementierung verspricht. Beide haben es die Plusse und die minus

Catch-Ansatz
```
some_promise_call()
.then(function(res) { logger.log(res) })
.catch(function(err) { logger.log(err) })
```
Vorteile
1. Alle Fehler behandelt werden, die von einem catch-block.
2. Auch fängt jede Ausnahme in der dann blockieren.
3. Verkettung mehrerer Erfolg Rückrufe
Nachteile
1. Im Fall der Verkettung wird es schwierig, zeigen unterschiedliche Fehlermeldungen.
Erfolg/Fehler-Ansatz
```
some_promise_call()
.then(function success(res) { logger.log(res) },
      function error(err) { logger.log(err) })
```
Vorteile
1. Sie bekommen feinkörnigen Fehler-Kontrolle.
2. Sie können gemeinsame Fehlerbehandlung für verschiedene Kategorien von Fehler wie db-Fehler 500 Fehler etc.
Nachteile
1. Müssen Sie noch weitere catch wenn Sie möchten-handler-Fehler, die ausgelöst durch den Erfolg-Rückruf
InformationsquelleAutor der Antwort aWebDeveloper

-1

Statt Worte, gutes Beispiel. Folgenden code (wenn der erste Versprechen gelöst):

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

ist identisch zu:

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

Aber mit verworfenen erste Versprechen, das nicht identisch ist:

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

InformationsquelleAutor der Antwort ktretyak

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.