Was ist der Unterschied zwischen dann und schließlich in einem Versprechen?

Sehe ich die docs für den Bluebird ' s endlich aber ich verstehe immer noch nicht ganz verstehen, die Differenz vs. then.

Klar zu sein: ich weiß genau, warum then wird aufgerufen, nachdem eine catch. Ich wollen es, um aufgerufen werden, nachdem ein Fang. Das ist die Absicht. Meine Frage ist: Wenn ich wollen code immer ausgeführt werden, unabhängig von dem Staat Versprechen, was ist der Unterschied zwischen then vs finally?

Baute ich diesen test:

var Promise = require("bluebird");

function test1 () {
    console.log("RESOLVE + THEN + CATCH + THEN");
    return new Promise((resolve, reject) => resolve())
       .then(() => console.log("then"))
       .catch(err => console.log("error:", err.message))
       .then(() => console.log("end"));
}

function test2 () {
    console.log("REJECT + THEN + CATCH + THEN");
    return new Promise((resolve, reject) => reject(new Error("rejected")))
       .then(() => console.log("then"))
       .catch(err => console.log("error:", err.message))
       .then(() => console.log("end"));
}

function test3 () {
    console.log("RESOLVE + THEN + CATCH + FINALLY");
    return new Promise((resolve, reject) => resolve())
       .then(() => console.log("then"))
       .catch(err => console.log("error:", err.message))
       .finally(() => console.log("end"));
}

function test4 () {
    console.log("REJECT + THEN + CATCH + FINALLY");
    return new Promise((resolve, reject) => reject(new Error("rejected")))
       .then(() => console.log("then"))
       .catch(err => console.log("error:", err.message))
       .finally(() => console.log("end"));
}

//run tests "sequentially" so console output doesn't get blended
setTimeout(test1, 500);
setTimeout(test2, 1000);
setTimeout(test3, 1500);
setTimeout(test4, 2000);

Diese tests vier Fällen:

.then(...).catch(...).then(...) mit einer abgeschlossenen Versprechen.
.then(...).catch(...).then(...) mit einer Ablehnung Versprechen.
.then(...).catch(...).finally(...) mit einer abgeschlossenen Versprechen.
.then(...).catch(...).finally(...) mit einer Ablehnung Versprechen.

Den Ergebnissen, die ich sehen, sind die Fälle 1+2 verhält sich identisch zu 3+4: Das Letzte bit (then oder finally je nach test) ausführt, egal, was passiert, bevor es, so wie vorgesehen. Die Ausgabe des Programms ist:

RESOLVE + THEN + CATCH + THEN
then
end
REJECT + THEN + CATCH + THEN
error: rejected
end
RESOLVE + THEN + CATCH + FINALLY
then
end
REJECT + THEN + CATCH + FINALLY
error: rejected
end

Nun, der Grund warum ich Frage ist, weil ich sah eine Kommentar zu dieser anderen Frage habe ich gefragt:

Nicht sicher, ob Sie Ihre Versprechungen, die Sie unterstützen, aber Sie sollten die letzten .then zu .finally so, dass die busy wird immer gelöscht.

Aus meiner sehr begrenzten wissen über then, und die oben genannten tests, es scheint, wie then ist ausreichend. Aber nach diesem Kommentar bin ich hinterfragen, mich selbst und über die Sicherheit der Verwendung von then ausführen "finally" code.

Also meine Frage ist: Was ist der Unterschied zwischen then und finally? Sie Aussehen wie Verhalten Sie sich der gleichen, aber wenn würde ich finally statt then?

wenn Sie immer fangen abgelehnt verspricht, heißt, Sie hat immer nur gelöst verspricht, dann gibt es natürlich wenig Unterschied... Bin ich fehlt der Punkt deiner Frage? dies alles scheint auf der Hand..
Es ist für Fälle, in denen die Versprechen könnte entweder gelöst werden, oder abgelehnt. In Ihrem Fall ist es immer gelöst, so dass es keinen Unterschied gibt.
die .fangen lässt es gelöst Versprechen..
1.: manchmal wollen Sie nicht fangen die Fehler an der Stelle, an der Sie entstehen, sondern in den Code, der diese Funktion nutzt, so dass Sie nicht fangen Sie. In diesem Fall können Sie nicht ersetzen then() und finally(). Manchmal muss man sauber sth. bis zu entscheiden, ob es ein Fehler war oder nicht. (nulling-Referenzen clearing-timeouts, ... stuff like that) das ist, wo Sie verwenden finally(). 2.: Die Funktion Sie passieren zu catch() könnte auch werfen, dann haben Sie abgelehnt Versprechen und die folgenden then() würde nicht aufgerufen werden.
gut, jetzt kann man nicht löschen. problem gelöst!

InformationsquelleAutor Jason C | 2016-12-13

7

Erste Unterschied: Manchmal wollen Sie nicht fangen die Fehler an der Stelle, an der Sie entstehen, sondern in den code, der diese Funktion nutzt, so dass Sie nicht fangen Sie. In diesem Fall können Sie nicht ersetzen then() und finally().

Manchmal muss man etwas reinigen, egal, ob es ein Fehler war oder nicht (nulling-Referenzen -, clearing-timeouts ... sowas). Das ist, wo Sie verwenden finally().

Zweite Unterschied: Die Funktion Sie passieren zu catch() könnte auch werfen, dann haben Sie abgelehnt Versprechen und die folgenden then() würde nicht aufgerufen werden.

(also ein schließlich vor einem catch noch ausführen auf einen Fehler, wusste nicht, dass)

Yeah, das ist der Punkt, der finally(). Es wird ausgeführt, unter keinen Umständen ohne änderung der aufgelösten Wert.

Möchten Sie vielleicht zu Lesen/google ein bisschen über try {} finally {} ohne Fang.

InformationsquelleAutor Thomas
4

.then und .finally sind nicht das gleiche.

.then ist das wichtigste Versprechen primitiv. Es ist das, was definiert ist, ist gründlich in die Promises/A+ spec und alle Versprechen Bibliotheken umzusetzen.

Einen Bluebird .endlich handler "aufgerufen werden, unabhängig von der Verheißung, Schicksal". So eine nicht behandelte Ausnahme löst dennoch ein .finally.
```
new Promise((resolve, reject) => reject(false))
  .finally(a => console.log('finally', a))
//finally undefined
//Unhandled rejection false

new Promise((resolve, reject) => reject(false))
  .then(a => console.log('then', a))
//Unhandled rejection false
```
.finally nicht ändern, der aufgelöst Wert der Versprechen und nicht das Ergebnis erhalten das Versprechen Kette.
```
new Promise((resolve, reject) => reject(false))
  .catch(e => {
    console.log(e)
    return 2
  })
  .finally(a => {
    console.log('finally', a)
    return 1
  })
  .then(res => console.log('res', res))
//finally undefined
//res 2
```
Den Methoden ähnlich Aussehen wie in den Testfällen wie die tests fangen Sie alle Fehler, und Sie sind nur mit Versprechungen für die Ablaufsteuerung, nicht unter Berufung auf die Werte resolve/abgelehnt entlang der Versprechen Kette.

Übrigens, wenn jemand anderes dies Lesen, nun, ich habe diese Konzepte nach unten, die ich gefunden habe, ein paar andere Dinge, und .tap() ist: tap ist eine Art auf halbem Weg zwischen then und finally: Wie then, nennt man das nicht auf Ablehnung, aber wie finally es ändert nicht das Ergebnis und damit das Ergebnis der vorherigen "überspringt". Ordentlich.

InformationsquelleAutor Matt
1

Allen Recht zu, nach etwas plaudern und eine Menge Hilfe von KevinB, dachte ich mindestens einen Unterschied. Betrachten Sie die folgenden zwei neue tests:
```
function test5 () {
    console.log("REJECT + THEN + CATCH/THROW + THEN");
    return new Promise((resolve, reject) => reject(new Error("rejected")))
       .then(() => console.log("then"))
       .catch(function(err) { throw new Error("error in catch"); })
       .then(() => console.log("end"));
}

function test6 () {
    console.log("REJECT + THEN + CATCH/THROW + FINALLY");
    return new Promise((resolve, reject) => reject(new Error("rejected")))
       .then(() => console.log("then"))
       .catch(function(err) { throw new Error("error in catch"); })
       .finally(() => console.log("end"));
}
```
In dieser das Versprechen abgelehnt wird, aber es wird ein Fehler geworfen catch.

Dem Versprechen endet letztlich abgelehnt, in beiden Fällen aber für die finally Fall die finally ist noch ausgeführt, die then nicht.

So das ist den Unterschied. Sie sind fast die gleichen mit der einzigen Ausnahme, dass, wenn ein Fehler geworfen wird, aus der catch handler finally führt, und then nicht.

Dies bedeutet, dass der Kommentar, den ich zitierte auch nicht haben, Verdienst: Wenn in meinem Fehlerbehandlung ein weiterer Fehler aufgetreten ist, eine then würde nicht garantieren, clean-up, aber eine finally würde. Das ist der Fall, dass ich fehlte.

Auch .finally hat keinen Einfluss auf den Wert behoben, für ein Versprechen, in der Erwägung, dass .then wird.
nicht wenn die Funktion undefined. Aber du hast Recht, finally() garantiert, dass das behoben wird nicht der Wert geändert werden.
Sorry, ich verstehe nicht, Ihre undefined Nachteil? Meinst du, dass Sie nicht sehen, die Wirkung, wenn Sie zurück undefined überall?
afaik jeder größeren Umsetzung der Versprechen, die in JS ändert nichts aufgelöst Wert, wenn die Funktion Sie passieren zu then() nicht einen Wert zurückgeben (aka undefined), sondern wird zu dem vorhergehenden Wert.
Native und Bluebird beheben undefined also gehe ich davon aus, dass die spec. new Promise(resolve => resolve(true)).then(res => console.log('res',res)).then(res => console.log('res', res))

InformationsquelleAutor Jason C

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.