Promises in JavaScript worden veel gebruikt om asynchrone bewerkingen te beheren. Ze hebben meestal een methode genaamd `then()` die wordt opgeroepen wanneer de promise wordt vervuld, en een methode genaamd `catch()` die wordt opgeroepen wanneer er een fout optreedt.
Hier is een voorbeeld van hoe je om kunt gaan met fouten in promises:
```
let promise = new Promise(function(resolve, reject) {
// een asynchrone bewerking wordt hier uitgevoerd
promise
.then(function(result) {
console.log(result); // dit wordt uitgevoerd als de promise wordt vervuld
})
.catch(function(error) {
console.log(error); // dit wordt uitgevoerd als er een fout optreedt
});
```
In dit voorbeeld, als de asynchrone bewerking succesvol is, wordt de `then()` methode uitgevoerd en wordt “Succes!” naar de console gelogd. Als er een fout optreedt, wordt de `catch()` methode uitgevoerd en wordt de fout naar de console gelogd.
Het is belangrijk op te merken dat de `catch()` methode alleen wordt opgeroepen als er een fout optreedt in de promise zelf. Als er een fout optreedt in de `then()`-methode, wordt deze niet afgehandeld door de `catch()`-methode. Een manier om dit probleem te omzeilen is door de `then()`-methode te laten terugvallen op een andere promise die eventuele fouten van de `then()`-methode kan opvangen.
```
promise
.then(function(result) {
return new Promise(function(resolve, reject) {
// een andere asynchrone bewerking wordt hier uitgevoerd
if (/* alles is goed */) {
resolve(“Alles is nog steeds goed!”);
}
else {
reject(Error(“Er ging iets mis in de then methode”));
}
});
})
.catch(function(error) {
console.log(error); // dit wordt nu opgeroepen als er een fout optreedt in de promise of in de then-methode
});
```
In dit herziene voorbeeld, als er een fout optreedt in de `then()`-methode, wordt deze nu afgehandeld door dezelfde `catch()`-methode die fouten in de promise afhandelt.
