Auf `Promise` und` dann() `Ausführungsreihenfolge

Question

Lassen Sie uns sagen, dass ich eine Funktion wie dieses ist

const fn =() => { 
    return work() 
    .then((finalResult) => {  // then 1 
     finish(finalResult); 
    }); 
}; 


const work =() => { 
    return Promise.resolve(1) 
    .then(() => {    // then 2 
     return process1(); 
    }).then((result) => {  // then 3 
     return process2(result); 
    }); 
}; 

Meine Frage: kann ich auf die Tatsache verlassen, dass finish wird AFTER process1 und process2 aufgerufen werden. Insbesondere ist then 1 dem Versprechen beigefügt, das von Promise.resolve(1) zurückgegeben wird, oder ist es dem Versprechen beigefügt, das von then 3 zurückgegeben wird.

Answer 1

Jeder then erwartet sein vorheriges Versprechen und dann der Reihe nach.

Wenn die vorherige Zusage einen Wert zurückgibt, ist das an den Rückruf übergebene Argument dieser Wert, oder wenn es eine andere Zusage zurückgibt, ist das Argument für den Rückruf der Wert, der von dieser Zusage zurückgegeben wird.

Section 2.2.6.1 der Versprechen und Spezifikation besagt:

Wenn/wenn Versprechen erfüllt ist, werden alle entsprechenden onFulfilled Rückrufe in der Reihenfolge ausgeführt werden müssen, von ihren Ursprung ruft dann.

Es wird garantiert, dass finish(finalResult) mit dem Ergebnis der process2(result) laufen wird (es sei denn, ein Fehler ist, natürlich.)

fand ich this article sehr aufschlussreich zu sein auf mit den Eingeweiden von Versprechungen in den Griff zu bekommen.

Answer 2

Dies ist in erster Linie eine Frage der Syntax. Was Sie tun, ist gleichwertig mit

const fn =() => { 
    const promiseA = work(); 
    const promiseB = promiseA.then(finish); // then 1 
    return promiseB; 
}; 

const work =() => { 
    const promiseC = Promise.resolve(1); 
    const promiseD = promiseC.then(process1); // then 2 
    const promiseE = promiseD.then(process2); // then 3 
    return promiseE; 
}; 

nur einige zusätzliche Variablen (und ich habe auch die Funktionsausdrücke vereinfacht).

Jetzt können wir klar sehen, dass das Ergebnis von work() ist, was von ihm zurückgegeben wird, so promiseA === promiseE. Also ja, finish ist mit dem Ergebnis des "then3" Aufrufs verkettet.

Zu wissen, dass then ein neues Versprechen erzeugt (für das spätere Ergebnis des Callback), statt das Original zurückkehren, können wir auch feststellen, dass promiseE !== promiseC, so finish ist nicht auf Promise.resolve(1) gekettet.