Versprechen können "bearbeitet" werden, nachdem sie abgelehnt wurden. Das heißt, man kann den Ablehnungsrückruf eines Versprechens aufrufen, bevor man einen Catch-Handler bereitstellt. Dieses Verhalten ist für mich etwas störend, weil man schreiben kann ...
var promise = new Promise(function(resolve) {
kjjdjf(); // this function does not exist });
... und in diesem Fall wird das Versprechen stillschweigend abgelehnt. Wenn man vergisst, einen Catch-Handler hinzuzufügen, wird der Code weiterhin fehlerfrei ausgeführt. Dies könnte zu anhaltenden und schwer zu findenden Fehlern führen.
Im Fall von Node.js ist die Rede davon, diese nicht behandelten Ablehnungen von Versprechungen zu behandeln und die Probleme zu melden. Dies bringt mich zu ES7 async / await. Betrachten Sie dieses Beispiel:
async function getReadyForBed() {
let teethPromise = brushTeeth();
let tempPromise = getRoomTemperature();
// Change clothes based on room temperature
let temp = await tempPromise;
// Assume `changeClothes` also returns a Promise
if(temp > 20) {
await changeClothes("warm");
} else {
await changeClothes("cold");
}
await teethPromise;
}
Angenommen, im obigen Beispiel wurde ZähnePromise abgelehnt (Fehler: keine Zahnpasta mehr!), Bevor getRoomTemperature erfüllt wurde. In diesem Fall würde es eine unbehandelte Ablehnung des Versprechens geben, bis die Zähne warten.
Mein Punkt ist folgender: Wenn wir nicht behandelte Ablehnungen von Versprechungen als Problem betrachten, werden Versprechungen, die später von einem Warten behandelt werden, möglicherweise versehentlich als Fehler gemeldet. Wenn wir jedoch unbehandelte Ablehnungen von Versprechungen als unproblematisch betrachten, werden legitime Fehler möglicherweise nicht gemeldet.
Gedanken dazu?
Dies hängt mit der Diskussion zusammen, die im Node.js-Projekt hier zu finden ist:
Standardverhalten bei der Erkennung nicht behandelter Ablehnungen
Wenn Sie den Code folgendermaßen schreiben:
function getReadyForBed() {
let teethPromise = brushTeeth();
let tempPromise = getRoomTemperature();
// Change clothes based on room temperature
return Promise.resolve(tempPromise)
.then(temp => {
// Assume `changeClothes` also returns a Promise
if (temp > 20) {
return Promise.resolve(changeClothes("warm"));
} else {
return Promise.resolve(changeClothes("cold"));
}
})
.then(teethPromise)
.then(Promise.resolve()); // since the async function returns nothing, ensure it's a resolved promise for `undefined`, unless it's previously rejected
}
Wenn getReadyForBed aufgerufen wird, wird synchron das endgültige (nicht zurückgegebene) Versprechen erstellt, das den gleichen Fehler "Nicht behandelte Ablehnung" aufweist wie jedes andere Versprechen (kann natürlich nichts sein, abhängig von der Engine). (Ich finde es sehr seltsam, dass Ihre Funktion nichts zurückgibt, was bedeutet, dass Ihre asynchrone Funktion ein Versprechen für undefiniert erzeugt.
Wenn ich jetzt ein Versprechen ohne einen Haken mache und später einen hinzufüge, wird die Warnung von den meisten "nicht behandelten Ablehnungsfehler" -Implementierungen tatsächlich zurückgezogen, wenn ich sie später bearbeite. Mit anderen Worten, async / await ändert nichts an der Diskussion über "unbehandelte Ablehnung" in irgendeiner Weise, die ich sehen kann.
Um diese Gefahr zu vermeiden, schreiben Sie den Code bitte folgendermaßen:
async function getReadyForBed() {
let teethPromise = brushTeeth();
let tempPromise = getRoomTemperature();
// Change clothes based on room temperature
var clothesPromise = tempPromise.then(function(temp) {
// Assume `changeClothes` also returns a Promise
if(temp > 20) {
return changeClothes("warm");
} else {
return changeClothes("cold");
}
});
/* Note that clothesPromise resolves to the result of `changeClothes`
due to Promise "chaining" magic. */
// Combine promises and await them both
await Promise.all(teethPromise, clothesPromise);
}
Beachten Sie, dass dies eine unbehandelte Ablehnung von Versprechungen verhindern sollte.