Uitzonderingen in promise ketens in JavaScript

Stel dat onze promise om de een of andere reden eindigt met een fout:

let promise = new Promise(function(resolve, reject) {
	setTimeout(function() {
		reject('error');
	}, 3000);
});

In dat geval gaat de code-uitvoering onmiddellijk naar de then waarin een fouthandler-functie aanwezig is, of naar de eerste catch, afhankelijk van wat eerder wordt aangetroffen.

Hier is een voorbeeld van de eerste situatie:

promise.then(
	function(result) {
		return result + '1';
	}
).then(
	function(result) {
		return result + '2';
	},
	function(error) {
		// uitvoering gaat onmiddellijk hiernaartoe
	}
).then(
	function(result) {
		console.log(result);
	}
);

Hier is een voorbeeld van de tweede situatie:

promise.then(
	function(result) {
		return result + '1';
	}
).then(
	function(result) {
		return result + '2';
	}
).catch(
	function(error) {
		// uitvoering gaat onmiddellijk hiernaartoe
	}
).then(
	function(result) {
		console.log(result);
	}
);

De fouthandler-functie heeft twee opties: als zij de uitzonderingssituatie heeft opgelost, kan zij een resultaat terugsturen via return en de uitvoering gaat verder in de keten. Als zij de fout niet heeft opgelost, kan zij of niets teruggeven, of een uitzondering werpen via throw. In dat geval gaat de uitvoering naar de volgende fouthandler (in then of catch - wat eerder wordt aangetroffen).

Over het algemeen worden alle fouten in de keten op één plek afgevangen: aan het einde van de keten wordt een catch geplaatst:

promise.then(
	function(result) {
		return result + '1';
	}
).then(
	function(result) {
		return result + '2';
	}
).catch(
	function(error) {
		// we komen hier terecht bij een fout
	}
);

Hierbij kan de uitzondering ontstaan in de promise zelf, of geworpen zijn via throw in elk onderdeel van de keten:

promise.then(
	function(result) {
		return result + '1';
	}
).then(
	function(result) {
		if (allesGoed) {
			return result + '2';
		} else {
			throw new Error('fout'); // gaan naar de dichtstbijzijnde handler
		}
	}
)
.then(
	function(result) {
		return result + '3';
	}
).catch(
	function(error) {
		// dichtstbijzijnde handler
	}
);

Houd er rekening mee dat catch specifiek nodig is voor het diagnosticeren van de fout: is deze oplosbaar of niet. Als de fout oplosbaar is, moet catch de oplossing doorgeven aan de volgende then. En als deze niet oplosbaar is (of deze specifieke catch weet gewoon niet hoe hij het moet oplossen), dan moeten we of niets teruggeven of een uitzondering werpen:

promise.then(
	function(result) {
		return result + '1';
	}
).then(
	function(result) {
		return result + '2';
	}
).catch(
	function(error) {
		if (foutOplosbaar) {
			return 'data'; // sturen naar de volgende then
		} else {
			// niets teruggeven of een uitzondering werpen
		}
	}
).then(
	function(result) {
		// hier lossen we de fout op
	}
);