Les promesses peuvent être "traitées" après avoir été rejetées. Autrement dit, on peut appeler le rappel de rejet d'une promesse avant de fournir un gestionnaire de capture. Ce comportement me dérange un peu car on peut écrire ...
var promise = new Promise(function(resolve) {
kjjdjf(); // this function does not exist });
... et dans ce cas, la Promesse est rejetée en silence. Si l'on oublie d'ajouter un gestionnaire de capture, le code continuera de s'exécuter silencieusement sans erreur. Cela pourrait conduire à des bogues persistants et difficiles à trouver.
Dans le cas de Node.js, il est question de gérer ces rejets de promesse non gérés et de signaler les problèmes. Cela m'amène à ES7 async / wait. Considérez cet exemple:
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;
}
Dans l'exemple ci-dessus, supposons que toothPromise a été rejetée (erreur: sans dentifrice!) Avant que getRoomTemperature ne soit remplie. Dans ce cas, il y aurait un rejet de promesse non géré jusqu'à l'attente de toothPromise.
Mon point est le suivant ... si nous considérons les rejets de promesses non gérés comme un problème, les promesses qui sont ensuite traitées par un attente peuvent être signalées par inadvertance comme des bogues. Là encore, si nous considérons que les rejets de promesses non gérés ne sont pas problématiques, les bugs légitimes pourraient ne pas être signalés.
Réflexions là-dessus?
Ceci est lié à la discussion trouvée dans le projet Node.js ici:
Comportement de détection de rejet non géré par défaut
si vous écrivez le code de cette façon:
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
}
Lorsque getReadyForBed est invoqué, il créera de manière synchrone la promesse finale (non retournée) - qui aura la même erreur de "rejet non géré" que toute autre promesse (cela pourrait être rien, bien sûr, selon le moteur). (Je trouve très étrange que votre fonction ne retourne rien, ce qui signifie que votre fonction asynchrone produit une promesse non définie.
Si je fais une promesse en ce moment sans problème et que j'en ajoute une plus tard, la plupart des implémentations d '"erreur de rejet non gérée" retireront réellement l'avertissement lorsque je le gérerai plus tard. En d'autres termes, async / wait ne modifie en rien la discussion sur le "rejet non géré".
pour éviter cet écueil, veuillez écrire le code de cette façon:
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);
}
Notez que cela devrait empêcher tout rejet de promesse non géré.