JavaScript debuggen II:
Error handler met try en catch
Het is bijna onmogelijk voor een programmeur om een 100% foutenvrij programma te schrijven. In elke programmeertaal krijg je te maken met uitzonderingen (exceptions) en fouten (errors). Gelukkig kun je die door je programma laten afhandelen zonder dat het vastloopt.
Foutafhandeling is een heel belangrijk onderdeel van een goed programma. In oudere versies van JavaScript was een goede foutafhandeling lastig te realiseren. In latere versies zijn goede mogelijkheden voor efficiënte foutafahandeling beschikbaar gemaakt.
Op deze pagina wordt één van die twee mogelijkheden besproken: try en catch.
Opmerking: Een andere methode om fouten op te vangen gaat met het event on error. Dat wordt besproken in het item JavaScript debuggen III: Error handler met 'onerror'.
Opmerking: Deze aanpak is primair bedoeld 'Runtime Errors' op te vangen in een 'gereed' programma. Maar je kunt dit ook heel goed gebruiken om programmeerfouten op te sporen tijdens het ontwikkelen van een nieuw JavaScript.
- Er worden drie items besproken:
- De opbouw van een code-block
try {...} catch {...}. - De opdracht throw
- Het code-block
finally
- De opbouw van een code-block
- We beginnen met een toepassing voor het debuggen (vinden van fouten in de code zelf) van een script.
De code hiervoor ziet er in zijn eenvoudigste vorm als volgt uit:
<script>
try {
var aa = 'Voorbeeld';
document.write(aaa);
} catch(err) {
document.write(err.message + "<br>");
}
</script>
- De uitvoer van dit programma is:
aaa is niet gedefinëerd
- In dit voorbeeld wordt een variable aa gedefinieerd. In de document.write-opdracht staat een tikfout. De uitvoering van het script gaat nu verder met het catch-block.
- De opdracht catch heeft één argument; het is dus een function. In het voorbeeld
is dat de variable err. Die wordt gekoppeld aan een intern object. Een van de properties van dat object
is message. De standaard foutboodschap die bij de fout hoort is dan beschikbaar in err.message.
- Als je een fout in een gereed script wilt opvangen is het handig om je eigen foutmeldingen te
maken. Je moet dan het programma-verloop verplaatsen van het try-block naar het catch-block.
Daarvoor gebruik je de opdracht throw. De syntax van throw is:throw "String met je foutmelding". In plaats van een string kun je ook true, false of een geheel getal (dus zonder decimale punt) meegeven aan throw. - Een voorbeeld: Stel: je hebt een variabele xx. Deze mag niet kleiner worden dan
1 en niet groter dan 10.
De code zou er als volgt uit kunnen zien:
try {
var xx;
.... (code waarin de waarde van xx wordt bepaald)...
.... (Stel: xx krijgt de waarde 15)...
if (xx < 1) throw "teKlein";
if (xx > 10) throw "teGroot";
} catch(err) {
document.write("**Fout: de waarde van xx is onjuist: " + xx)
if (err == "teKlein" )
document.write(" (xx is minimaal 1)");
if (err == "teGroot" )
document.write(" (xx is maximaal 10)");
} - De uitvoer van dit programma is:
**Fout: de waarde van xx is onjuist: 15 (xx is maximaal 10)
- Het is mogelijk om fouten te negeren, d.w.z. een fout wel opvangen maar er niets mee doen. In zo'n geval
laat je het catch-block leeg. De code luidt dan:
catch {}.
- Tenslotte is er nog het block finally. De code in dat block wordt altijd uitgevoerd na
de beëindiging van het block
try {...} catch {...}, ongeacht of er een fout-conditie is opgetreden (waardoor het catch-block wordt geactiveerd) of niet. - De code van het finally-block volgt direct na het block
try {...} catch {...}. - De structuur ziet er dan uiteindelijk zo uit:
try {...} catch {...} finally {...} - Meestal is het finally-block niet nodig. Je kunt het dan gewoon weglaten.
Gebruik:
- De code staat in de <HEAD> of in de <BODY>, afhankelijk van de toepassing.
- Het is mogelijk om try...catch te nesten, zoals in in onderstaande illustratie:
try {
... //block code
... //block code
try {
... //block code
... //block code
} catch(err) {
... //block code
... //block code
}
... // meer code
} catch(err_1) {
... // nog meer code
... // nog meer code
} finally {
... // en nóg meer code
}
Opmerking:
Voor het debuggen van een script dat je nog aan het ontwikkelen bent zijn er ook andere mogelijkheden dan
wat op deze bladzijde is beschreven. Elke grote browser heeft een apart console voor het tonen van foutmeldingen en waarschuwingen.
Alle moderne browsers hebben tegenwoordig een eigen debugger aan boord of stellen die beschikbaar via een plug-in. Zie het
item JavaScript debuggen in de browser.
Het is ook mogelijk om JavaScript te debuggen met behulp van een ander JavaScript-programma. Zie daarvoor
voorbeeld 3 in het item JavaScript debuggen. Die
methode is echter aan het verouderen.
