Befor es in JS "Promise" gab hat man Callback Funktionen genutzt. Also
man übergab einer Funktion eine Callback Funktion, die am Ende
aufgerufen wurde, normalerweise mit dem Resultat oder einem Fehler.
Dann kamen die Promise Objekte. Das ist eine gute Abstraktion davon, die
das konsistenter macht. Dort kann man mit then() die Callback Funktion
übergeben. Man hat 2, eine für Fehler, und eine für wenn alles OK ist.
Die Promise kann das Resultat speichern, und es kennt die Zustände
ausstehend, fertig, oder Fehler.
Bei "new Promise" kann man eine Funktion übergeben, die sofort
aufgerufen wird, und wenn sie fertig ist, den an sie übergebenen
Callback aufruft, der dann den Wert der Promise setzt. Das ist
eigentlich wie früher mit den Callbacks.
Man kann zwischen den 2 Varianten, Callback übergeben und Promise zurück
geben, Konvertieren, in nodejs gibt es dafür fertige Funktionen
"util.promisify" und "util.callbackify". In dem sinne ist das
äquivalent.
So ein Promise Objekt hat aber noch einige Vorteile. Man kann z.B. auf
mehrere Ergebnisse auf einmal warten, und weil man beim Callback, das
man an then() übergibt, ein Promise Objekt übergeben kann, kommt man
ohne tief verschachtelte Callbacks aus. Und bei den Callbacks die man
der then() Funktion übergibt, hat man das Problem nicht, dass man einen
Fehler haben könnte, und vergisst, den Abzufangen und den reject
Callback aufzurufen, dass kann die then() funktion auch.
Hier gibt es nun noch etwas spezielles, bei den Promise Objekten. In JS
gibt es das Konzept eines Objekts, dass then-able ist. Das ist jedes
Objekt, dass eine then funktion hat, der ein Callback übergeben wird,
der dann aufgerufen wird. Das ist unter anderem für nicht native Promise
Implementierungen wichtig, was bei der Einführung wichtig war. Eine
Promise ist ein then-able Objekt, und then-able Objekte werden wie
Promises behandelt. Man kann also z.B. sowas machen:
1 | Promise.resolve({then(resolve){ setTimeout(resolve, 1000); }})
|
2 | .then(()=>{console.log("I was called 1 second later");});
|
Das ganze war manchmal aber immer noch fehleranfällig, und nicht ganz so
praktisch wie möglich. z.B. hatte man bei "new Promise" immer noch
callbacks, die man vergessen könnte, aufzurufen (und die Variante mit
den then-ablen Objekten von oben kannten die wenigsten). Deshalb wurden
async Functionen, und das await Keyword eingeführt.
Eine async Funktion gibt eine Promise zurück. Und immer eine Native, man
kann die nicht ersetzen*. Gibt es eine Exception, wird die Promise immer
rejected, da kann man (fast) nichts falsch machen. Und nur in den async
Funktionen, gibt es das await keyword. Laut spec wartet man damit auf
Promises. Tatsächlich wird aber einfach die then() Funktion aufgerufen,
und dieser eine Continuation der then() Funktion übergeben.
1 | (async()=>{
|
2 | await { then(continuation){ setTimeout(continuation, 1000); } };
|
3 | console.log("I was called 1 second later");
|
4 | })();
|
Die Continuation ist wie eine simple callback Funktion, die die Async
funktion fortsetzt. Sie wird aber niemals synchron aufgerufen:
1 | (async()=>{
|
2 | console.log(1);
|
3 | console.log(await {
|
4 | then(continuation){
|
5 | console.log(2);
|
6 | continuation("result");
|
7 | console.log(3);
|
8 | }
|
9 | });
|
10 | console.log(4);
|
11 | })();
|
Ausgabe:
Wie hier zu sehen ist, wird continuation nicht sofort ausgeführt,
sondern erst beim nächsten event loop Durchgang.
Letztendlich kommt es aber aufs gleiche raus. Man kann auf eine Promise
Warten.
Das heisst aber auch, dass bei jedem Await, eine Funktion unterbrochen,
und andere Funktionen im event loop aufgerufen werden können. Aber nur
dort, die restlichen teile der Funktion werden niemals unterbrochen.
Ein paar Fallstricke hat das auch, aber es ist viel einfacher damit
umzugehen als beim Multithreading, und manchmal kann man das sogar
anderweitig ausnutzen.
Zu guter letzt, der Vollständigkeit halber, sind noch Generator
Funktionen zu erwähnen. Die gab es schon lange vor Promise Objekten und
vor async-await. Dort werden die Funktionen beim "yield" Keyword
unterbrochen, und das beim Aufruf des Generators zurückgegebene Objekt
hat eine next() Funktion, quasi aine continuation, das führt die
Funktion fort, und man kann das yield so sogar werte zurückgeben lassen.
1 | function* mygenerator(){
|
2 | console.log(1);
|
3 | console.log(yield 2);
|
4 | console.log(yield 3);
|
5 | }
|
6 | var x = mygenerator();
|
7 | console.log(0);
|
8 | console.log(x.next("a"));
|
9 | console.log(x.next("b"));
|
10 | console.log(x.next("c"));
|
Ausgabe:
1 | 0
|
2 | 1
|
3 | { value: 2, done: false }
|
4 | b
|
5 | { value: 3, done: false }
|
6 | c
|
7 | { value: undefined, done: true }
|
In gewissem Sinne ist das analog zu async Funktionen, man könnte die
damit simulieren, das wäre aber weder Sinvoll noch Praktisch. Sind dafür
für anderes gut. So ein Generator kann man auch mit for(x of g) nutzen.
Und das lässt sich auch mit async kombinieren, nennt sich dann async
generatoren. Die kann man mit "for await(x of ag)" iterieren.
Da gäbe es noch viel mehr zu sagen, aber das dürfte alles wichtige
zusammenfassen.
Thread beobachten
Seitenaufteilung abschalten