Exception handling syntax
Keywords provided by a programming language
- 67 min read
- 1 chapter
Learn it on Lably
Most commonly, error handling uses a try { /* ... */ } catch (/* ... */) { /* ... */ } finally { /* ... */ } chain of blocks, and errors are created via a throw statement, but there is significant variation in naming and syntax.
Catalogue of exception handling syntaxes
Ada
- Exception declarations
<span id="mwNQ"></span><span class="n" id="mwNg">Some_Error</span> <span class="p" id="mwNw">:</span> <span class="kr" id="mwOA">exception</span><span class="p" id="mwOQ">;</span>
- Raising exceptions
<span id="mwPg"></span><span class="kr" id="mwPw">raise</span> <span class="n" id="mwQA">Some_Error</span><span class="p" id="mwQQ">;</span> <span class="kr" id="mwQg">raise</span> <span class="n" id="mwQw">Some_Error</span> <span class="kn" id="mwRA">with</span> <span class="s" id="mwRQ">"Out of memory"</span><span class="p" id="mwRg">;</span> <span class="c1" id="mwRw">-- specific diagnostic message</span>
- Exception handling and propagation
<span id="mwTA"></span><span class="kn" id="mwTQ">with</span> <span class="n" id="mwTg">Ada.Exceptions</span><span class="p" id="mwTw">,</span> <span class="n" id="mwUA">Ada</span><span class="p" id="mwUQ">.</span><span class="n" id="mwUg">Text_IO</span><span class="p" id="mwUw">;</span> <span class="kd" id="mwVA">procedure</span> <span class="nf" id="mwVQ">Foo</span> <span class="kr" id="mwVg">is</span> <span class="n" id="mwVw">Some_Error</span> <span class="p" id="mwWA">:</span> <span class="kr" id="mwWQ">exception</span><span class="p" id="mwWg">;</span> <span class="kr" id="mwWw">begin</span> <span class="n" id="mwXA">Do_Something_Interesting</span><span class="p" id="mwXQ">;</span> <span class="kr" id="mwXg">exception</span> <span class="c1" id="mwXw">-- Start of exception handlers</span> <span class="kr" id="mwYA">when</span> <span class="n" id="mwYQ">Constraint_Error</span> <span class="p" id="mwYg">=></span> <span class="p" id="mwYw">...</span> <span class="c1" id="mwZA">-- Handle constraint error</span> <span class="kr" id="mwZQ">when</span> <span class="n" id="mwZg">Storage_Error</span> <span class="p" id="mwZw">=></span> <span class="c1" id="mwaA">-- Propagate Storage_Error as a different exception with a useful message</span> <span class="kr" id="mwaQ">raise</span> <span class="n" id="mwag">Some_Error</span> <span class="kn" id="mwaw">with</span> <span class="s" id="mwbA">"Out of memory"</span><span class="p" id="mwbQ">;</span> <span class="kr" id="mwbg">when</span> <span class="n" id="mwbw">Error</span> <span class="p" id="mwcA">:</span> <span class="kr" id="mwcQ">others</span> <span class="p" id="mwcg">=></span> <span class="c1" id="mwcw">-- Handle all others</span> <span class="n" id="mwdA">Ada</span><span class="p" id="mwdQ">.</span><span class="n" id="mwdg">Text_IO</span><span class="p" id="mwdw">.</span><span class="n" id="mweA">Put</span><span class="p" id="mweQ">(</span><span class="s" id="mweg">"Exception: "</span><span class="p" id="mwew">);</span> <span class="n" id="mwfA">Ada</span><span class="p" id="mwfQ">.</span><span class="n" id="mwfg">Text_IO</span><span class="p" id="mwfw">.</span><span class="n" id="mwgA">Put_Line</span><span class="p" id="mwgQ">(</span><span class="n" id="mwgg">Ada</span><span class="p" id="mwgw">.</span><span class="n" id="mwhA">Exceptions</span><span class="p" id="mwhQ">.</span><span class="n" id="mwhg">Exception_Name</span><span class="p" id="mwhw">(</span><span class="n" id="mwiA">Error</span><span class="p" id="mwiQ">));</span> <span class="n" id="mwig">Ada</span><span class="p" id="mwiw">.</span><span class="n" id="mwjA">Text_IO</span><span class="p" id="mwjQ">.</span><span class="n" id="mwjg">Put_Line</span><span class="p" id="mwjw">(</span><span class="n" id="mwkA">Ada</span><span class="p" id="mwkQ">.</span><span class="n" id="mwkg">Exceptions</span><span class="p" id="mwkw">.</span><span class="n" id="mwlA">Exception_Message</span><span class="p" id="mwlQ">(</span><span class="n" id="mwlg">Error</span><span class="p" id="mwlw">));</span> <span class="kr" id="mwmA">end</span> <span class="nf" id="mwmQ">Foo</span><span class="p" id="mwmg">;</span>
Assembly language
Most assembly languages have a macro instruction or an interrupt address available for the particular system to intercept events such as illegal opcodes, overflow, and divide by zero. IBM and UNIVAC mainframes have the STXIT macro. Digital Equipment Corporation RT11 systems have trap vectors. Windows has specific module calls to trap program errors.
ATS
<span id="mwqg"></span><span class="k" id="mwqw">exception</span> <span class="nc" id="mwrA">MyException</span> <span class="k" id="mwrQ">of</span> <span class="o" id="mwrg">(</span><span class="kt" id="mwrw">string</span><span class="o" id="mwsA">,</span> <span class="kt" id="mwsQ">int</span><span class="o" id="mwsg">)</span> <span class="c" id="mwsw">(* exceptions can carry a value *)</span> <span class="n" id="mwtA">implement</span> <span class="n" id="mwtQ">main0</span> <span class="bp" id="mwtg">()</span><span class="o" id="mwtw">:</span> <span class="n" id="mwuA">void</span> <span class="o" id="mwuQ">=</span> <span class="k" id="mwug">try</span> <span class="o" id="mwuw">$</span><span class="k" id="mwvA">raise</span> <span class="nc" id="mwvQ">MyException</span><span class="o" id="mwvg">(</span><span class="s2" id="mwvw">"not enough food"</span><span class="o" id="mwwA">,</span> <span class="mi" id="mwwQ">2</span><span class="o" id="mwwg">)</span> <span class="k" id="mwww">with</span> <span class="o" id="mwxA">|</span> <span class="o" id="mwxQ">~</span><span class="nc" id="mwxg">MyException</span><span class="o" id="mwxw">(</span><span class="n" id="mwyA">s</span><span class="o" id="mwyQ">,</span> <span class="n" id="mwyg">i</span><span class="o" id="mwyw">)</span> <span class="o" id="mwzA">=></span> <span class="k" id="mwzQ">begin</span> <span class="o" id="mwzg">$</span><span class="n" id="mwzw">extfcall</span><span class="o" id="mw0A">(</span><span class="n" id="mw0Q">void</span><span class="o" id="mw0g">,</span> <span class="s2" id="mw0w">"fprintf"</span><span class="o" id="mw1A">,</span> <span class="n" id="mw1Q">stderr_ref</span><span class="o" id="mw1g">,</span> <span class="s2" id="mw1w">"%s: %d"</span><span class="o" id="mw2A">,</span> <span class="n" id="mw2Q">s</span><span class="o" id="mw2g">,</span> <span class="n" id="mw2w">i</span><span class="o" id="mw3A">);</span> <span class="n" id="mw3Q">fileref_close</span><span class="o" id="mw3g">(</span><span class="n" id="mw3w">stderr_ref</span><span class="o" id="mw4A">);</span> <span class="k" id="mw4Q">end</span>
Bash
<span id="mw5w"></span><span class="ch" id="mw6A">#!/usr/bin/env bash</span> <span class="c1" id="mw6Q">#set -e provides another error mechanism</span> print_error<span class="o" id="mw6g">()</span><span class="w" id="mw6w"> </span><span class="o" id="mw7A">{</span> <span class="w" id="mw7Q"> </span><span class="nb" id="mw7g">echo</span><span class="w" id="mw7w"> </span><span class="s2" id="mw8A">"there was an error"</span> <span class="o" id="mw8Q">}</span> <span class="nb" id="mw8g">trap</span><span class="w" id="mw8w"> </span>print_error<span class="w" id="mw9A"> </span><span class="nb" id="mw9Q">exit</span><span class="w" id="mw9g"> </span><span class="c1" id="mw9w">#list signals to trap</span> <span class="nv" id="mw-A">tempfile</span><span class="o" id="mw-Q">=</span><span class="sb" id="mw-g">`</span>mktemp<span class="sb" id="mw-w">`</span> <span class="nb" id="mw_A">trap</span><span class="w" id="mw_Q"> </span><span class="s2" id="mw_g">"rm </span><span class="nv" id="mw_w">$tempfile</span><span class="s2" id="mwAQA">"</span><span class="w" id="mwAQE"> </span><span class="nb" id="mwAQI">exit</span> ./other.sh<span class="w" id="mwAQM"> </span><span class="o" id="mwAQQ">||</span><span class="w" id="mwAQU"> </span><span class="nb" id="mwAQY">echo</span><span class="w" id="mwAQc"> </span>warning:<span class="w" id="mwAQg"> </span>other<span class="w" id="mwAQk"> </span>failed <span class="nb" id="mwAQo">echo</span><span class="w" id="mwAQs"> </span>oops<span class="o" id="mwAQw">)</span> <span class="nb" id="mwAQ0">echo</span><span class="w" id="mwAQ4"> </span>never<span class="w" id="mwAQ8"> </span>printedOne can set a trap for multiple errors, responding to any signal with syntax like:
trap 'echo Error at line ${LINENO}' ERR
BASIC
An On Error goto/gosub structure is used in BASIC and is quite different from modern exception handling; in BASIC there is only one global handler whereas in modern exception handling, exception handlers are stacked.
<span id="mwAR8"></span><span class="kr" id="mwASA">ON ERROR</span><span class="w" id="mwASE"> </span><span class="kr" id="mwASI">GOTO</span><span class="w" id="mwASM"> </span><span class="nl" id="mwASQ">handler</span> <span class="kr" id="mwASU">OPEN</span><span class="w" id="mwASY"> </span><span class="s2" id="mwASc">"Somefile.txt"</span><span class="w" id="mwASg"> </span><span class="kr" id="mwASk">FOR</span><span class="w" id="mwASo"> </span><span class="kr" id="mwASs">INPUT</span><span class="w" id="mwASw"> </span><span class="k" id="mwAS0">AS</span><span class="w" id="mwAS4"> </span><span class="err" id="mwAS8">#</span><span class="il" id="mwATA">1</span> <span class="kr" id="mwATE">CLOSE</span><span class="w" id="mwATI"> </span><span class="err" id="mwATM">#</span><span class="il" id="mwATQ">1</span> <span class="kr" id="mwATU">PRINT</span><span class="w" id="mwATY"> </span><span class="s2" id="mwATc">"File opened successfully"</span> <span class="kr" id="mwATg">END</span> <span class="nl" id="mwATk">handler:</span> <span class="kr" id="mwATo">PRINT</span><span class="w" id="mwATs"> </span><span class="s2" id="mwATw">"File does not exist"</span> <span class="kr" id="mwAT0">END</span><span class="w" id="mwAT4"> </span><span class="c1" id="mwAT8">' RESUME may be used instead which returns control to original position.</span>
C
C does not provide direct support to exception handling: it is the programmer's responsibility to prevent errors in the first place and test return values from the functions.
In any case, a possible way to implement exception handling in standard C is to use setjmp()/longjmp() functions:
<span id="mwAUw"></span><span class="cp" id="mwAU0">#include</span><span class="w" id="mwAU4"> </span><span class="cpf" id="mwAU8"><setjmp.h></span> <span class="cp" id="mwAVA">#include</span><span class="w" id="mwAVE"> </span><span class="cpf" id="mwAVI"><stdio.h></span> <span class="cp" id="mwAVM">#include</span><span class="w" id="mwAVQ"> </span><span class="cpf" id="mwAVU"><stdlib.h></span> <span class="k" id="mwAVY">enum</span><span class="w" id="mwAVc"> </span><span class="n" id="mwAVg">Exception</span><span class="w" id="mwAVk"> </span><span class="p" id="mwAVo">{</span><span class="w" id="mwAVs"> </span> <span class="w" id="mwAVw"> </span><span class="n" id="mwAV0">NoExceptionThrown</span><span class="w" id="mwAV4"> </span><span class="o" id="mwAV8">=</span><span class="w" id="mwAWA"> </span><span class="mi" id="mwAWE">0</span><span class="p" id="mwAWI">,</span> <span class="w" id="mwAWM"> </span><span class="n" id="mwAWQ">OutOfBoundsException</span><span class="w" id="mwAWU"> </span><span class="o" id="mwAWY">=</span><span class="w" id="mwAWc"> </span><span class="mi" id="mwAWg">1</span><span class="p" id="mwAWk">,</span><span class="w" id="mwAWo"> </span> <span class="w" id="mwAWs"> </span><span class="n" id="mwAWw">ArithmeticException</span><span class="w" id="mwAW0"> </span><span class="o" id="mwAW4">=</span><span class="w" id="mwAW8"> </span><span class="mi" id="mwAXA">2</span><span class="p" id="mwAXE">,</span> <span class="w" id="mwAXI"> </span><span class="c1" id="mwAXM">// ...</span> <span class="p" id="mwAXQ">}</span><span class="w" id="mwAXU"> </span><span class="n" id="mwAXY">GLOBAL_EXCEPTION_STATE</span><span class="p" id="mwAXc">;</span> <span class="kt" id="mwAXg">jmp_buf</span><span class="w" id="mwAXk"> </span><span class="n" id="mwAXo">state</span><span class="p" id="mwAXs">;</span> <span class="kt" id="mwAXw">int</span><span class="w" id="mwAX0"> </span><span class="nf" id="mwAX4">main</span><span class="p" id="mwAX8">(</span><span class="kt" id="mwAYA">int</span><span class="w" id="mwAYE"> </span><span class="n" id="mwAYI">argc</span><span class="p" id="mwAYM">,</span><span class="w" id="mwAYQ"> </span><span class="kt" id="mwAYU">char</span><span class="o" id="mwAYY">*</span><span class="w" id="mwAYc"> </span><span class="n" id="mwAYg">argv</span><span class="p" id="mwAYk">[])</span><span class="w" id="mwAYo"> </span><span class="p" id="mwAYs">{</span> <span class="w" id="mwAYw"> </span><span class="c1" id="mwAY0">// try</span> <span class="w" id="mwAY4"> </span><span class="k" id="mwAY8">if</span><span class="w" id="mwAZA"> </span><span class="p" id="mwAZE">(</span><span class="o" id="mwAZI">!</span><span class="n" id="mwAZM">setjmp</span><span class="p" id="mwAZQ">(</span><span class="n" id="mwAZU">state</span><span class="p" id="mwAZY">))</span><span class="w" id="mwAZc"> </span><span class="p" id="mwAZg">{</span> <span class="w" id="mwAZk"> </span><span class="c1" id="mwAZo">// code that manipulates 'GLOBAL_EXCEPTION_STATE'</span> <span class="w" id="mwAZs"> </span><span class="k" id="mwAZw">if</span><span class="w" id="mwAZ0"> </span><span class="p" id="mwAZ4">(</span><span class="n" id="mwAZ8">GLOBAL_EXCEPTION_STATE</span><span class="w" id="mwAaA"> </span><span class="o" id="mwAaE">!=</span><span class="w" id="mwAaI"> </span><span class="n" id="mwAaM">NoExceptionThrown</span><span class="p" id="mwAaQ">)</span><span class="w" id="mwAaU"> </span><span class="p" id="mwAaY">{</span> <span class="w" id="mwAac"> </span><span class="n" id="mwAag">longjmp</span><span class="p" id="mwAak">(</span><span class="n" id="mwAao">state</span><span class="p" id="mwAas">,</span><span class="w" id="mwAaw"> </span><span class="mi" id="mwAa0">0</span><span class="p" id="mwAa4">);</span><span class="w" id="mwAa8"> </span><span class="c1" id="mwAbA">// go to exception catching...</span> <span class="w" id="mwAbE"> </span><span class="p" id="mwAbI">}</span> <span class="w" id="mwAbM"> </span><span class="p" id="mwAbQ">}</span><span class="w" id="mwAbU"> </span><span class="k" id="mwAbY">else</span><span class="w" id="mwAbc"> </span><span class="p" id="mwAbg">{</span> <span class="w" id="mwAbk"> </span><span class="k" id="mwAbo">switch</span><span class="w" id="mwAbs"> </span><span class="p" id="mwAbw">(</span><span class="n" id="mwAb0">GLOBAL_EXCEPTION_STATE</span><span class="p" id="mwAb4">)</span><span class="w" id="mwAb8"> </span><span class="p" id="mwAcA">{</span><span class="w" id="mwAcE"> </span> <span class="w" id="mwAcI"> </span><span class="c1" id="mwAcM">// catch (OutOfBoundsException)</span> <span class="w" id="mwAcQ"> </span><span class="k" id="mwAcU">case</span><span class="w" id="mwAcY"> </span><span class="no" id="mwAcc">OutOfBoundsException</span><span class="p" id="mwAcg">:</span> <span class="w" id="mwAck"> </span><span class="n" id="mwAco">printf</span><span class="p" id="mwAcs">(</span><span class="s" id="mwAcw">"OutOfBoundsException caught"</span><span class="p" id="mwAc0">);</span> <span class="w" id="mwAc4"> </span><span class="k" id="mwAc8">break</span><span class="p" id="mwAdA">;</span> <span class="w" id="mwAdE"> </span><span class="c1" id="mwAdI">// catch (ArithmeticException)</span> <span class="w" id="mwAdM"> </span><span class="k" id="mwAdQ">case</span><span class="w" id="mwAdU"> </span><span class="no" id="mwAdY">ArithmeticException</span><span class="p" id="mwAdc">:</span> <span class="w" id="mwAdg"> </span><span class="n" id="mwAdk">printf</span><span class="p" id="mwAdo">(</span><span class="s" id="mwAds">"ArithmeticException caught"</span><span class="p" id="mwAdw">);</span> <span class="w" id="mwAd0"> </span><span class="k" id="mwAd4">break</span><span class="p" id="mwAd8">;</span> <span class="w" id="mwAeA"> </span><span class="c1" id="mwAeE">// additional catch cases...</span> <span class="w" id="mwAeI"> </span><span class="k" id="mwAeM">default</span><span class="o" id="mwAeQ">:</span><span class="w" id="mwAeU"> </span><span class="c1" id="mwAeY">// catch (...)</span> <span class="w" id="mwAec"> </span><span class="n" id="mwAeg">printf</span><span class="p" id="mwAek">(</span><span class="s" id="mwAeo">"Unknown exception caught"</span><span class="p" id="mwAes">);</span> <span class="w" id="mwAew"> </span><span class="p" id="mwAe0">}</span> <span class="w" id="mwAe4"> </span><span class="p" id="mwAe8">}</span> <span class="w" id="mwAfA"> </span><span class="k" id="mwAfE">return</span><span class="w" id="mwAfI"> </span><span class="n" id="mwAfM">EXIT_SUCCESS</span><span class="p" id="mwAfQ">;</span> <span class="p" id="mwAfU">}</span>Microsoft-specific
Two types exist:
- Structured Exception Handling (SEH)
- Vectored Exception Handling (VEH, introduced in Windows XP)
Example of SEH in C programming language:
<span id="mwAgI"></span><span class="kt" id="mwAgM">int</span><span class="w" id="mwAgQ"> </span><span class="nf" id="mwAgU">filterExpression</span><span class="p" id="mwAgY">(</span><span class="n" id="mwAgc">EXCEPTION_POINTERS</span><span class="o" id="mwAgg">*</span><span class="w" id="mwAgk"> </span><span class="n" id="mwAgo">ep</span><span class="p" id="mwAgs">)</span><span class="w" id="mwAgw"> </span><span class="p" id="mwAg0">{</span> <span class="w" id="mwAg4"> </span><span class="n" id="mwAg8">ep</span><span class="o" id="mwAhA">-></span><span class="n" id="mwAhE">ContextRecord</span><span class="o" id="mwAhI">-></span><span class="n" id="mwAhM">Eip</span><span class="w" id="mwAhQ"> </span><span class="o" id="mwAhU">+=</span><span class="w" id="mwAhY"> </span><span class="mi" id="mwAhc">8</span><span class="p" id="mwAhg">;</span><span class="w" id="mwAhk"> </span><span class="c1" id="mwAho">// divide instruction may be encoded from 2 to 8 bytes</span> <span class="w" id="mwAhs"> </span><span class="k" id="mwAhw">return</span><span class="w" id="mwAh0"> </span><span class="n" id="mwAh4">EXCEPTION_CONTINUE_EXECUTION</span><span class="p" id="mwAh8">;</span> <span class="p" id="mwAiA">}</span> <span class="kt" id="mwAiE">int</span><span class="w" id="mwAiI"> </span><span class="nf" id="mwAiM">main</span><span class="p" id="mwAiQ">(</span><span class="kt" id="mwAiU">int</span><span class="w" id="mwAiY"> </span><span class="n" id="mwAic">argc</span><span class="p" id="mwAig">,</span><span class="w" id="mwAik"> </span><span class="kt" id="mwAio">char</span><span class="o" id="mwAis">*</span><span class="w" id="mwAiw"> </span><span class="n" id="mwAi0">argv</span><span class="p" id="mwAi4">[])</span><span class="w" id="mwAi8"> </span><span class="p" id="mwAjA">{</span> <span class="w" id="mwAjE"> </span><span class="k" id="mwAjI">static</span><span class="w" id="mwAjM"> </span><span class="kt" id="mwAjQ">int</span><span class="w" id="mwAjU"> </span><span class="n" id="mwAjY">zero</span><span class="w" id="mwAjc"> </span><span class="o" id="mwAjg">=</span><span class="w" id="mwAjk"> </span><span class="mi" id="mwAjo">0</span><span class="p" id="mwAjs">;</span> <span class="w" id="mwAjw"> </span><span class="kr" id="mwAj0">__try</span><span class="w" id="mwAj4"> </span><span class="p" id="mwAj8">{</span> <span class="w" id="mwAkA"> </span><span class="n" id="mwAkE">zero</span><span class="w" id="mwAkI"> </span><span class="o" id="mwAkM">=</span><span class="w" id="mwAkQ"> </span><span class="mi" id="mwAkU">1</span><span class="w" id="mwAkY"> </span><span class="o" id="mwAkc">/</span><span class="w" id="mwAkg"> </span><span class="n" id="mwAkk">zero</span><span class="p" id="mwAko">;</span> <span class="w" id="mwAks"> </span><span class="k" id="mwAkw">asm</span><span class="w" id="mwAk0"> </span><span class="p" id="mwAk4">{</span> <span class="w" id="mwAk8"> </span><span class="n" id="mwAlA">nop</span> <span class="w" id="mwAlE"> </span><span class="n" id="mwAlI">nop</span> <span class="w" id="mwAlM"> </span><span class="n" id="mwAlQ">nop</span> <span class="w" id="mwAlU"> </span><span class="n" id="mwAlY">nop</span> <span class="w" id="mwAlc"> </span><span class="n" id="mwAlg">nop</span> <span class="w" id="mwAlk"> </span><span class="n" id="mwAlo">nop</span> <span class="w" id="mwAls"> </span><span class="n" id="mwAlw">nop</span> <span class="w" id="mwAl0"> </span><span class="p" id="mwAl4">}</span><span class="w" id="mwAl8"> </span> <span class="w" id="mwAmA"> </span><span class="n" id="mwAmE">printf</span><span class="p" id="mwAmI">(</span><span class="s" id="mwAmM">"Past the exception.</span><span class="se" id="mwAmQ">\n</span><span class="s" id="mwAmU">"</span><span class="p" id="mwAmY">);</span> <span class="w" id="mwAmc"> </span><span class="p" id="mwAmg">}</span><span class="w" id="mwAmk"> </span><span class="kr" id="mwAmo">__except</span><span class="w" id="mwAms"> </span><span class="p" id="mwAmw">(</span><span class="n" id="mwAm0">filterExpression</span><span class="p" id="mwAm4">(</span><span class="n" id="mwAm8">GetExceptionInformation</span><span class="p" id="mwAnA">()))</span><span class="w" id="mwAnE"> </span><span class="p" id="mwAnI">{</span> <span class="w" id="mwAnM"> </span><span class="n" id="mwAnQ">printf</span><span class="p" id="mwAnU">(</span><span class="s" id="mwAnY">"Handler called.</span><span class="se" id="mwAnc">\n</span><span class="s" id="mwAng">"</span><span class="p" id="mwAnk">);</span> <span class="w" id="mwAno"> </span><span class="p" id="mwAns">}</span> <span class="w" id="mwAnw"> </span><span class="k" id="mwAn0">return</span><span class="w" id="mwAn4"> </span><span class="mi" id="mwAn8">0</span><span class="p" id="mwAoA">;</span> <span class="p" id="mwAoE">}</span>C#
A try block must have at least one catch or finally clause and at most one finally clause.
<span id="mwAow"></span><span class="k" id="mwAo0">namespace</span><span class="w" id="mwAo4"> </span><span class="nn" id="mwAo8">Wikipedia.Examples</span><span class="p" id="mwApA">;</span> <span class="k" id="mwApE">using</span><span class="w" id="mwApI"> </span><span class="nn" id="mwApM">System</span><span class="p" id="mwApQ">;</span> <span class="k" id="mwApU">using</span><span class="w" id="mwApY"> </span><span class="nn" id="mwApc">System.Web</span><span class="p" id="mwApg">;</span> <span class="k" id="mwApk">public</span><span class="w" id="mwApo"> </span><span class="k" id="mwAps">class</span><span class="w" id="mwApw"> </span><span class="nc" id="mwAp0">Example</span> <span class="p" id="mwAp4">{</span> <span class="w" id="mwAp8"> </span><span class="k" id="mwAqA">static</span><span class="w" id="mwAqE"> </span><span class="k" id="mwAqI">void</span><span class="w" id="mwAqM"> </span><span class="nf" id="mwAqQ">Main</span><span class="p" id="mwAqU">(</span><span class="kt" id="mwAqY">string</span><span class="p" id="mwAqc">[]</span><span class="w" id="mwAqg"> </span><span class="n" id="mwAqk">argsg</span><span class="p" id="mwAqo">)</span> <span class="w" id="mwAqs"> </span><span class="p" id="mwAqw">{</span> <span class="w" id="mwAq0"> </span><span class="k" id="mwAq4">try</span> <span class="w" id="mwAq8"> </span><span class="p" id="mwArA">{</span> <span class="w" id="mwArE"> </span><span class="c1" id="mwArI">// Code that could throw an exception.</span> <span class="w" id="mwArM"> </span><span class="p" id="mwArQ">}</span> <span class="w" id="mwArU"> </span><span class="k" id="mwArY">catch</span><span class="w" id="mwArc"> </span><span class="p" id="mwArg">(</span><span class="n" id="mwArk">HttpException</span><span class="w" id="mwAro"> </span><span class="n" id="mwArs">ex</span><span class="p" id="mwArw">)</span> <span class="w" id="mwAr0"> </span><span class="p" id="mwAr4">{</span> <span class="w" id="mwAr8"> </span><span class="c1" id="mwAsA">// Handles a HttpException (System.Web.HttpException).</span> <span class="w" id="mwAsE"> </span><span class="c1" id="mwAsI">// The exception object is stored in "ex".</span> <span class="w" id="mwAsM"> </span><span class="p" id="mwAsQ">}</span> <span class="w" id="mwAsU"> </span><span class="k" id="mwAsY">catch</span><span class="w" id="mwAsc"> </span><span class="p" id="mwAsg">(</span><span class="n" id="mwAsk">Exception</span><span class="p" id="mwAso">)</span> <span class="w" id="mwAss"> </span><span class="p" id="mwAsw">{</span> <span class="w" id="mwAs0"> </span><span class="c1" id="mwAs4">// Handles any CLR exception that is not a HttpException.</span> <span class="w" id="mwAs8"> </span><span class="c1" id="mwAtA">// Since the exception has not been given an identifier, it cannot be referenced.</span> <span class="w" id="mwAtE"> </span><span class="p" id="mwAtI">}</span> <span class="w" id="mwAtM"> </span><span class="k" id="mwAtQ">catch</span> <span class="w" id="mwAtU"> </span><span class="p" id="mwAtY">{</span> <span class="w" id="mwAtc"> </span><span class="c1" id="mwAtg">// Handles anything that might be thrown, including non-CLR exceptions</span> <span class="w" id="mwAtk"> </span><span class="c1" id="mwAto">// (such as native C++ exceptions)</span> <span class="w" id="mwAts"> </span><span class="p" id="mwAtw">}</span> <span class="w" id="mwAt0"> </span><span class="k" id="mwAt4">finally</span> <span class="w" id="mwAt8"> </span><span class="p" id="mwAuA">{</span> <span class="w" id="mwAuE"> </span><span class="c1" id="mwAuI">// Always run when leaving the try block (including catch clauses), regardless of whether any exceptions were thrown or whether they were handled.</span> <span class="w" id="mwAuM"> </span><span class="c1" id="mwAuQ">// Often used to clean up and close resources such a file handles.</span> <span class="w" id="mwAuU"> </span><span class="c1" id="mwAuY">// May not be run when Environment.FailFast() is called and in other system-wide exceptional conditions (e.g. power loss), or when the process crashes due to an exception in another thread.</span> <span class="w" id="mwAuc"> </span><span class="p" id="mwAug">}</span> <span class="w" id="mwAuk"> </span><span class="p" id="mwAuo">}</span> <span class="p" id="mwAus">}</span>C++
<span id="mwAvE"></span><span class="k" id="mwAvI">import</span><span class="w" id="mwAvM"> </span><span class="n" id="mwAvQ">std</span><span class="p" id="mwAvU">;</span> <span class="k" id="mwAvY">using</span><span class="w" id="mwAvc"> </span><span class="n" id="mwAvg">std</span><span class="o" id="mwAvk">::</span><span class="n" id="mwAvo">exception</span><span class="p" id="mwAvs">;</span> <span class="k" id="mwAvw">using</span><span class="w" id="mwAv0"> </span><span class="n" id="mwAv4">std</span><span class="o" id="mwAv8">::</span><span class="n" id="mwAwA">runtime_error</span><span class="p" id="mwAwE">;</span> <span class="kt" id="mwAwI">int</span><span class="w" id="mwAwM"> </span><span class="nf" id="mwAwQ">main</span><span class="p" id="mwAwU">(</span><span class="kt" id="mwAwY">int</span><span class="w" id="mwAwc"> </span><span class="n" id="mwAwg">argc</span><span class="p" id="mwAwk">,</span><span class="w" id="mwAwo"> </span><span class="kt" id="mwAws">char</span><span class="o" id="mwAww">*</span><span class="w" id="mwAw0"> </span><span class="n" id="mwAw4">argv</span><span class="p" id="mwAw8">[])</span><span class="w" id="mwAxA"> </span><span class="p" id="mwAxE">{</span> <span class="w" id="mwAxI"> </span><span class="k" id="mwAxM">try</span><span class="w" id="mwAxQ"> </span><span class="p" id="mwAxU">{</span> <span class="w" id="mwAxY"> </span><span class="c1" id="mwAxc">// do something (might throw an exception)</span> <span class="w" id="mwAxg"> </span><span class="n" id="mwAxk">mightThrow</span><span class="p" id="mwAxo">();</span> <span class="w" id="mwAxs"> </span><span class="p" id="mwAxw">}</span><span class="w" id="mwAx0"> </span><span class="k" id="mwAx4">catch</span><span class="w" id="mwAx8"> </span><span class="p" id="mwAyA">(</span><span class="k" id="mwAyE">const</span><span class="w" id="mwAyI"> </span><span class="n" id="mwAyM">runtime_error</span><span class="o" id="mwAyQ">&</span><span class="w" id="mwAyU"> </span><span class="n" id="mwAyY">e</span><span class="p" id="mwAyc">)</span><span class="w" id="mwAyg"> </span><span class="p" id="mwAyk">{</span> <span class="w" id="mwAyo"> </span><span class="c1" id="mwAys">// handle a runtime_error e</span> <span class="w" id="mwAyw"> </span><span class="p" id="mwAy0">}</span><span class="w" id="mwAy4"> </span><span class="k" id="mwAy8">catch</span><span class="w" id="mwAzA"> </span><span class="p" id="mwAzE">(</span><span class="k" id="mwAzI">const</span><span class="w" id="mwAzM"> </span><span class="n" id="mwAzQ">exception</span><span class="o" id="mwAzU">&</span><span class="w" id="mwAzY"> </span><span class="n" id="mwAzc">e</span><span class="p" id="mwAzg">)</span><span class="w" id="mwAzk"> </span><span class="p" id="mwAzo">{</span> <span class="w" id="mwAzs"> </span><span class="c1" id="mwAzw">// catches all exceptions as e</span> <span class="w" id="mwAz0"> </span><span class="p" id="mwAz4">}</span><span class="w" id="mwAz8"> </span><span class="k" id="mwA0A">catch</span><span class="w" id="mwA0E"> </span><span class="p" id="mwA0I">(...)</span><span class="w" id="mwA0M"> </span><span class="p" id="mwA0Q">{</span> <span class="w" id="mwA0U"> </span><span class="c1" id="mwA0Y">// catches all thrown types (including primitives or objects that do not extend exception), not previously caught by a catch block before</span> <span class="w" id="mwA0c"> </span><span class="p" id="mwA0g">}</span> <span class="p" id="mwA0k">}</span>In C++, a resource acquisition is initialization technique can be used to clean up resources in exceptional situations. C++ intentionally does not support finally. The outer braces for the method are optional.
ColdFusion Markup Language (CFML)
Script syntax
<span id="mwA1o"></span><span class="o" id="mwA1s"><</span><span class="nx" id="mwA1w">cfscript</span><span class="o" id="mwA10">></span> <span class="k" id="mwA14">try</span><span class="w" id="mwA18"> </span><span class="p" id="mwA2A">{</span> <span class="w" id="mwA2E"> </span><span class="c1" id="mwA2I">// throw CF9+</span> <span class="w" id="mwA2M"> </span><span class="k" id="mwA2Q">throw</span><span class="p" id="mwA2U">(</span><span class="kr" id="mwA2Y">type</span><span class="o" id="mwA2c">=</span><span class="s2" id="mwA2g">"TypeOfException"</span><span class="p" id="mwA2k">,</span><span class="w" id="mwA2o"> </span><span class="nx" id="mwA2s">message</span><span class="o" id="mwA2w">=</span><span class="s2" id="mwA20">"Oops"</span><span class="p" id="mwA24">,</span><span class="w" id="mwA28"> </span><span class="nx" id="mwA3A">detail</span><span class="o" id="mwA3E">=</span><span class="s2" id="mwA3I">"xyz"</span><span class="p" id="mwA3M">);</span> <span class="w" id="mwA3Q"> </span><span class="c1" id="mwA3U">// alternate throw syntax:</span> <span class="w" id="mwA3Y"> </span><span class="k" id="mwA3c">throw</span><span class="w" id="mwA3g"> </span><span class="s2" id="mwA3k">"Oops"</span><span class="p" id="mwA3o">;</span><span class="w" id="mwA3s"> </span><span class="c1" id="mwA3w">// this equivalent to the "message" value in the above example</span> <span class="p" id="mwA30">}</span><span class="w" id="mwA34"> </span><span class="k" id="mwA38">catch</span><span class="w" id="mwA4A"> </span><span class="p" id="mwA4E">(</span><span class="nx" id="mwA4I">any</span><span class="w" id="mwA4M"> </span><span class="nx" id="mwA4Q">e</span><span class="p" id="mwA4U">)</span><span class="w" id="mwA4Y"> </span><span class="p" id="mwA4c">{</span> <span class="w" id="mwA4g"> </span><span class="nx" id="mwA4k">writeOutput</span><span class="p" id="mwA4o">(</span><span class="s2" id="mwA4s">"Error: "</span><span class="w" id="mwA4w"> </span><span class="o" id="mwA40">&</span><span class="w" id="mwA44"> </span><span class="nx" id="mwA48">e</span><span class="p" id="mwA5A">.</span><span class="nx" id="mwA5E">message</span><span class="p" id="mwA5I">);</span> <span class="w" id="mwA5M"> </span><span class="nx" id="mwA5Q">rethrow</span><span class="p" id="mwA5U">;</span><span class="w" id="mwA5Y"> </span><span class="c1" id="mwA5c">// CF9+</span> <span class="p" id="mwA5g">}</span><span class="w" id="mwA5k"> </span><span class="k" id="mwA5o">finally</span><span class="w" id="mwA5s"> </span><span class="p" id="mwA5w">{</span><span class="w" id="mwA50"> </span><span class="c1" id="mwA54">// CF9+</span> <span class="w" id="mwA58"> </span><span class="nx" id="mwA6A">writeOutput</span><span class="p" id="mwA6E">(</span><span class="s2" id="mwA6I">"I run even if no error"</span><span class="p" id="mwA6M">);</span> <span class="p" id="mwA6Q">}</span> <span class="o" id="mwA6U"><</span><span class="err" id="mwA6Y">/cfscript></span>Adobe ColdFusion documentation
Tag syntax
<span id="mwA7A"></span><span class="nb" id="mwA7E"><cftry></span> code that may cause an exception <span class="nb" id="mwA7I"><cfcatch</span> <span class="p" id="mwA7M">...</span><span class="nb" id="mwA7Q">></span> <span class="nb" id="mwA7U"><cftry></span> First level of exception handling code <span class="nb" id="mwA7Y"><cfcatch</span> <span class="p" id="mwA7c">...</span><span class="nb" id="mwA7g">></span> Second level of exception handling code <span class="nb" id="mwA7k"></cfcatch></span> <span class="p" id="mwA7o"><</span><span class="nt" id="mwA7s">cffinally</span><span class="p" id="mwA7w">></span> final code <span class="p" id="mwA70"></</span><span class="nt" id="mwA74">cffinally</span><span class="p" id="mwA78">></span> <span class="nb" id="mwA8A"></cftry></span> <span class="nb" id="mwA8E"></cfcatch></span> <span class="nb" id="mwA8I"></cftry></span>
Adobe ColdFusion documentation
Railo-Lucee specific syntax
Added to the standard syntax above, CFML dialects of Railo and Lucee allow a retry statement.
This statement returns processing to the start of the prior try block.
CFScript example:
<span id="mwA9k"></span><span class="k" id="mwA9o">try</span><span class="w" id="mwA9s"> </span><span class="p" id="mwA9w">{</span> <span class="w" id="mwA90"> </span><span class="c1" id="mwA94">// code which could result in an exception</span> <span class="p" id="mwA98">}</span><span class="w" id="mwA-A"> </span><span class="k" id="mwA-E">catch</span><span class="w" id="mwA-I"> </span><span class="p" id="mwA-M">(</span><span class="nx" id="mwA-Q">any</span><span class="w" id="mwA-U"> </span><span class="nx" id="mwA-Y">e</span><span class="p" id="mwA-c">){</span> <span class="w" id="mwA-g"> </span><span class="nx" id="mwA-k">retry</span><span class="p" id="mwA-o">;</span> <span class="p" id="mwA-s">}</span>Tag-syntax example:
<span id="mwA-8"></span><span class="nb" id="mwA_A"><cftry></span> <span class="cm" id="mwA_E"><!--- code which could result in an exception ---></span> <span class="nb" id="mwA_I"><cfcatch></span> <span class="p" id="mwA_M"><</span><span class="nt" id="mwA_Q">cfretry</span><span class="p" id="mwA_U">></span> <span class="nb" id="mwA_Y"></cfcatch></span> <span class="nb" id="mwA_c"></cftry></span>
D
<span id="mwA_0"></span><span class="k" id="mwA_4">import</span><span class="w" id="mwA_8"> </span><span class="n" id="mwBAA">std</span><span class="p" id="mwBAE">.</span><span class="n" id="mwBAI">stdio</span><span class="p" id="mwBAM">;</span> <span class="kt" id="mwBAQ">int</span><span class="w" id="mwBAU"> </span><span class="n" id="mwBAY">main</span><span class="p" id="mwBAc">(</span><span class="nb" id="mwBAg">string</span><span class="p" id="mwBAk">[]</span><span class="w" id="mwBAo"> </span><span class="n" id="mwBAs">args</span><span class="p" id="mwBAw">)</span><span class="w" id="mwBA0"> </span><span class="p" id="mwBA4">{</span> <span class="w" id="mwBA8"> </span><span class="k" id="mwBBA">try</span><span class="w" id="mwBBE"> </span><span class="p" id="mwBBI">{</span> <span class="w" id="mwBBM"> </span><span class="c1" id="mwBBQ">// do something that might throw an exception</span> <span class="w" id="mwBBU"> </span><span class="p" id="mwBBY">}</span><span class="w" id="mwBBc"> </span><span class="k" id="mwBBg">catch</span><span class="w" id="mwBBk"> </span><span class="p" id="mwBBo">(</span><span class="n" id="mwBBs">FileException</span><span class="w" id="mwBBw"> </span><span class="n" id="mwBB0">e</span><span class="p" id="mwBB4">)</span><span class="w" id="mwBB8"> </span><span class="p" id="mwBCA">{</span> <span class="w" id="mwBCE"> </span><span class="c1" id="mwBCI">// handle exceptions of type FileException</span> <span class="w" id="mwBCM"> </span><span class="p" id="mwBCQ">}</span><span class="w" id="mwBCU"> </span><span class="k" id="mwBCY">catch</span><span class="w" id="mwBCc"> </span><span class="p" id="mwBCg">(</span><span class="n" id="mwBCk">Object</span><span class="w" id="mwBCo"> </span><span class="n" id="mwBCs">o</span><span class="p" id="mwBCw">)</span><span class="w" id="mwBC0"> </span><span class="p" id="mwBC4">{</span> <span class="w" id="mwBC8"> </span><span class="c1" id="mwBDA">// handle any other exceptions</span> <span class="w" id="mwBDE"> </span><span class="n" id="mwBDI">writefln</span><span class="p" id="mwBDM">(</span><span class="s" id="mwBDQ">"Unhandled exception: "</span><span class="p" id="mwBDU">,</span><span class="w" id="mwBDY"> </span><span class="n" id="mwBDc">o</span><span class="p" id="mwBDg">);</span> <span class="w" id="mwBDk"> </span><span class="k" id="mwBDo">return</span><span class="w" id="mwBDs"> </span><span class="mi" id="mwBDw">1</span><span class="p" id="mwBD0">;</span> <span class="w" id="mwBD4"> </span><span class="p" id="mwBD8">}</span> <span class="w" id="mwBEA"> </span><span class="k" id="mwBEE">return</span><span class="w" id="mwBEI"> </span><span class="mi" id="mwBEM">0</span><span class="p" id="mwBEQ">;</span> <span class="p" id="mwBEU">}</span>In D, a finally clause or the resource acquisition is initialization technique can be used to clean up resources in exceptional situations.
Delphi
- Exception declarations
<span id="mwBFI"></span><span class="k" id="mwBFM">type</span><span class="w" id="mwBFQ"> </span><span class="n" id="mwBFU">ECustom</span><span class="w" id="mwBFY"> </span><span class="o" id="mwBFc">=</span><span class="w" id="mwBFg"> </span><span class="k" id="mwBFk">class</span><span class="p" id="mwBFo">(</span><span class="n" id="mwBFs">Exception</span><span class="p" id="mwBFw">)</span><span class="w" id="mwBF0"> </span><span class="c1" id="mwBF4">// Exceptions are children of the class Exception.</span> <span class="w" id="mwBF8"> </span><span class="kp" id="mwBGA">private</span> <span class="w" id="mwBGE"> </span><span class="n" id="mwBGI">FCustomData</span><span class="o" id="mwBGM">:</span><span class="w" id="mwBGQ"> </span><span class="n" id="mwBGU">SomeType</span><span class="o" id="mwBGY">;</span><span class="w" id="mwBGc"> </span><span class="c1" id="mwBGg">// Exceptions may have custom extensions.</span> <span class="w" id="mwBGk"> </span><span class="kp" id="mwBGo">public</span> <span class="w" id="mwBGs"> </span><span class="k" id="mwBGw">constructor</span><span class="w" id="mwBG0"> </span><span class="nf" id="mwBG4">CreateCustom</span><span class="p" id="mwBG8">(</span><span class="n" id="mwBHA">Data</span><span class="o" id="mwBHE">:</span><span class="w" id="mwBHI"> </span><span class="n" id="mwBHM">SomeType</span><span class="p" id="mwBHQ">)</span><span class="o" id="mwBHU">;</span><span class="w" id="mwBHY"> </span><span class="c1" id="mwBHc">// Needs an implementation</span> <span class="w" id="mwBHg"> </span><span class="k" id="mwBHk">property</span><span class="w" id="mwBHo"> </span><span class="py" id="mwBHs">CustomData</span><span class="o" id="mwBHw">:</span><span class="w" id="mwBH0"> </span><span class="n" id="mwBH4">SomeType</span><span class="w" id="mwBH8"> </span><span class="kp" id="mwBIA">read</span><span class="w" id="mwBIE"> </span><span class="nf" id="mwBII">FCustomData</span><span class="o" id="mwBIM">;</span> <span class="w" id="mwBIQ"> </span><span class="k" id="mwBIU">end</span><span class="o" id="mwBIY">;</span>
- Raising exceptions
<span id="mwBIs"></span><span class="k" id="mwBIw">raise</span><span class="w" id="mwBI0"> </span><span class="n" id="mwBI4">Exception</span><span class="o" id="mwBI8">.</span><span class="n" id="mwBJA">Create</span><span class="p" id="mwBJE">(</span><span class="s" id="mwBJI">'Message'</span><span class="p" id="mwBJM">)</span><span class="o" id="mwBJQ">;</span> <span class="k" id="mwBJU">raise</span><span class="w" id="mwBJY"> </span><span class="n" id="mwBJc">Exception</span><span class="o" id="mwBJg">.</span><span class="n" id="mwBJk">CreateFmt</span><span class="p" id="mwBJo">(</span><span class="s" id="mwBJs">'Message with values: %d, %d'</span><span class="o" id="mwBJw">,</span><span class="p" id="mwBJ0">[</span><span class="n" id="mwBJ4">value1</span><span class="o" id="mwBJ8">,</span><span class="w" id="mwBKA"> </span><span class="n" id="mwBKE">value2</span><span class="p" id="mwBKI">])</span><span class="o" id="mwBKM">;</span><span class="w" id="mwBKQ"> </span><span class="c1" id="mwBKU">// See SysUtils.Format() for parameters.</span> <span class="k" id="mwBKY">raise</span><span class="w" id="mwBKc"> </span><span class="n" id="mwBKg">ECustom</span><span class="o" id="mwBKk">.</span><span class="n" id="mwBKo">CreateCustom</span><span class="p" id="mwBKs">(</span><span class="n" id="mwBKw">X</span><span class="p" id="mwBK0">)</span><span class="o" id="mwBK4">;</span>
- Exception handling and propagation
<span id="mwBLc"></span><span class="k" id="mwBLg">try</span><span class="w" id="mwBLk"> </span><span class="c1" id="mwBLo">// For finally.</span> <span class="w" id="mwBLs"> </span><span class="k" id="mwBLw">try</span><span class="w" id="mwBL0"> </span><span class="c1" id="mwBL4">// For except.</span> <span class="w" id="mwBL8"> </span><span class="o" id="mwBMA">...</span><span class="w" id="mwBME"> </span><span class="c1" id="mwBMI">// Code that may raise an exception.</span> <span class="w" id="mwBMM"> </span><span class="k" id="mwBMQ">except</span> <span class="w" id="mwBMU"> </span><span class="k" id="mwBMY">on</span><span class="w" id="mwBMc"> </span><span class="n" id="mwBMg">C</span><span class="o" id="mwBMk">:</span><span class="n" id="mwBMo">ECustom</span><span class="w" id="mwBMs"> </span><span class="k" id="mwBMw">do</span> <span class="w" id="mwBM0"> </span><span class="k" id="mwBM4">begin</span> <span class="w" id="mwBM8"> </span><span class="o" id="mwBNA">...</span><span class="w" id="mwBNE"> </span><span class="c1" id="mwBNI">// Handle ECustom.</span> <span class="w" id="mwBNM"> </span><span class="o" id="mwBNQ">...</span><span class="w" id="mwBNU"> </span><span class="k" id="mwBNY">if</span><span class="w" id="mwBNc"> </span><span class="n" id="mwBNg">Predicate</span><span class="p" id="mwBNk">(</span><span class="n" id="mwBNo">C</span><span class="o" id="mwBNs">.</span><span class="n" id="mwBNw">CustomData</span><span class="p" id="mwBN0">)</span><span class="w" id="mwBN4"> </span><span class="k" id="mwBN8">then</span><span class="w" id="mwBOA"> </span><span class="o" id="mwBOE">...</span> <span class="w" id="mwBOI"> </span><span class="k" id="mwBOM">end</span><span class="o" id="mwBOQ">;</span> <span class="w" id="mwBOU"> </span><span class="k" id="mwBOY">on</span><span class="w" id="mwBOc"> </span><span class="n" id="mwBOg">S</span><span class="o" id="mwBOk">:</span><span class="n" id="mwBOo">ESomeOtherException</span><span class="w" id="mwBOs"> </span><span class="k" id="mwBOw">do</span> <span class="w" id="mwBO0"> </span><span class="k" id="mwBO4">begin</span> <span class="w" id="mwBO8"> </span><span class="c1" id="mwBPA">// Propagate as an other exception.</span> <span class="w" id="mwBPE"> </span><span class="k" id="mwBPI">raise</span><span class="w" id="mwBPM"> </span><span class="n" id="mwBPQ">EYetAnotherException</span><span class="o" id="mwBPU">.</span><span class="n" id="mwBPY">Create</span><span class="p" id="mwBPc">(</span><span class="n" id="mwBPg">S</span><span class="o" id="mwBPk">.</span><span class="n" id="mwBPo">Message</span><span class="p" id="mwBPs">)</span><span class="o" id="mwBPw">;</span><span class="w" id="mwBP0"> </span> <span class="w" id="mwBP4"> </span><span class="k" id="mwBP8">end</span><span class="o" id="mwBQA">;</span> <span class="w" id="mwBQE"> </span><span class="k" id="mwBQI">on</span><span class="w" id="mwBQM"> </span><span class="n" id="mwBQQ">E</span><span class="o" id="mwBQU">:</span><span class="n" id="mwBQY">Exception</span><span class="w" id="mwBQc"> </span><span class="k" id="mwBQg">do</span> <span class="w" id="mwBQk"> </span><span class="k" id="mwBQo">begin</span> <span class="w" id="mwBQs"> </span><span class="o" id="mwBQw">...</span><span class="w" id="mwBQ0"> </span><span class="c1" id="mwBQ4">// Handle other exceptions.</span> <span class="w" id="mwBQ8"> </span><span class="k" id="mwBRA">raise</span><span class="o" id="mwBRE">;</span><span class="w" id="mwBRI"> </span><span class="c1" id="mwBRM">// Propagate.</span> <span class="w" id="mwBRQ"> </span><span class="k" id="mwBRU">end</span><span class="o" id="mwBRY">;</span> <span class="w" id="mwBRc"> </span><span class="k" id="mwBRg">end</span><span class="o" id="mwBRk">;</span><span class="w" id="mwBRo"> </span> <span class="k" id="mwBRs">finally</span> <span class="w" id="mwBRw"> </span><span class="c1" id="mwBR0">// Code to execute whether or not an exception is raised (e.g., clean-up code).</span> <span class="k" id="mwBR4">end</span><span class="o" id="mwBR8">;</span>
Erlang
<span id="mwBSU"></span><span class="k" id="mwBSY">try</span> <span class="w" id="mwBSc"> </span><span class="c" id="mwBSg">% some dangerous code</span> <span class="k" id="mwBSk">catch</span> <span class="w" id="mwBSo"> </span><span class="nn" id="mwBSs">throw</span><span class="p" id="mwBSw">:{</span><span class="n" id="mwBS0">someError</span><span class="p" id="mwBS4">,</span><span class="w" id="mwBS8"> </span><span class="nv" id="mwBTA">X</span><span class="p" id="mwBTE">}</span><span class="w" id="mwBTI"> </span><span class="o" id="mwBTM">-></span><span class="w" id="mwBTQ"> </span><span class="n" id="mwBTU">ok</span><span class="p" id="mwBTY">;</span><span class="w" id="mwBTc"> </span><span class="c" id="mwBTg">% handle an exception</span> <span class="w" id="mwBTk"> </span><span class="nn" id="mwBTo">error</span><span class="p" id="mwBTs">:</span><span class="nv" id="mwBTw">X</span><span class="w" id="mwBT0"> </span><span class="o" id="mwBT4">-></span><span class="w" id="mwBT8"> </span><span class="n" id="mwBUA">ok</span><span class="p" id="mwBUE">;</span><span class="w" id="mwBUI"> </span><span class="c" id="mwBUM">% handle another exception</span> <span class="w" id="mwBUQ"> </span><span class="p" id="mwBUU">_:_</span><span class="w" id="mwBUY"> </span><span class="o" id="mwBUc">-></span><span class="w" id="mwBUg"> </span><span class="n" id="mwBUk">ok</span><span class="w" id="mwBUo"> </span><span class="c" id="mwBUs">% handle all exceptions</span> <span class="k" id="mwBUw">after</span> <span class="w" id="mwBU0"> </span><span class="c" id="mwBU4">% clean up</span> <span class="k" id="mwBU8">end</span>F#
In addition to the OCaml-based try...with, F# also has the separate try...finally construct, which has the same behavior as a try block with a finally clause in other .NET languages.
For comparison, this is a translation of the C# sample above.
<span id="mwBVs"></span><span class="k" id="mwBVw">try</span> <span class="w" id="mwBV0"> </span><span class="k" id="mwBV4">try</span> <span class="w" id="mwBV8"> </span><span class="bp" id="mwBWA">()</span><span class="w" id="mwBWE"> </span><span class="c" id="mwBWI">(* Code that could throw an exception. *)</span> <span class="w" id="mwBWM"> </span><span class="k" id="mwBWQ">with</span> <span class="w" id="mwBWU"> </span><span class="o" id="mwBWY">|</span><span class="w" id="mwBWc"> </span><span class="o" id="mwBWg">:?</span><span class="w" id="mwBWk"> </span><span class="nn" id="mwBWo">System</span><span class="p" id="mwBWs">.</span><span class="nn" id="mwBWw">Net</span><span class="p" id="mwBW0">.</span><span class="n" id="mwBW4">WebException</span><span class="w" id="mwBW8"> </span><span class="k" id="mwBXA">as</span><span class="w" id="mwBXE"> </span><span class="n" id="mwBXI">ex</span><span class="w" id="mwBXM"> </span><span class="o" id="mwBXQ">-></span><span class="w" id="mwBXU"> </span><span class="bp" id="mwBXY">()</span><span class="w" id="mwBXc"> </span><span class="c" id="mwBXg">(* Handles a WebException. The exception object is stored in </span><span class="s" id="mwBXk">"ex"</span><span class="c" id="mwBXo">. *)</span> <span class="w" id="mwBXs"> </span><span class="o" id="mwBXw">|</span><span class="w" id="mwBX0"> </span><span class="o" id="mwBX4">:?</span><span class="w" id="mwBX8"> </span><span class="kt" id="mwBYA">exn</span><span class="w" id="mwBYE"> </span><span class="o" id="mwBYI">-></span><span class="w" id="mwBYM"> </span><span class="bp" id="mwBYQ">()</span><span class="w" id="mwBYU"> </span><span class="c" id="mwBYY">(* Handles any CLR exception. Since the exception has not been given an identifier, it cannot be referenced. *)</span> <span class="w" id="mwBYc"> </span><span class="o" id="mwBYg">|</span><span class="w" id="mwBYk"> </span><span class="o" id="mwBYo">_</span><span class="w" id="mwBYs"> </span><span class="o" id="mwBYw">-></span><span class="w" id="mwBY0"> </span><span class="bp" id="mwBY4">()</span><span class="w" id="mwBY8"> </span><span class="c" id="mwBZA">(* Handles anything that might be thrown, including non-CLR exceptions. *)</span> <span class="k" id="mwBZE">finally</span> <span class="w" id="mwBZI"> </span><span class="bp" id="mwBZM">()</span><span class="w" id="mwBZQ"> </span> <span class="w" id="mwBZU"> </span><span class="c" id="mwBZY">(*</span> <span class="c" id="mwBZc"> Always run when leaving the try block, regardless of whether any exceptions were thrown or whether they were handled.</span> <span class="c" id="mwBZg"> Often used to clean up and close resources such a file handles.</span> <span class="c" id="mwBZk"> May not be run when Environment.FailFast() is called and in other system-wide exceptional conditions (e.g. power loss), or when the process crashes due to an exception in another thread.</span> <span class="c" id="mwBZo"> *)</span>
For comparison, this is translation of the OCaml sample below.
<span id="mwBZ8"></span><span class="k" id="mwBaA">exception</span><span class="w" id="mwBaE"> </span><span class="n" id="mwBaI">MyException</span><span class="w" id="mwBaM"> </span><span class="k" id="mwBaQ">of</span><span class="w" id="mwBaU"> </span><span class="kt" id="mwBaY">string</span><span class="w" id="mwBac"> </span><span class="o" id="mwBag">*</span><span class="w" id="mwBak"> </span><span class="n" id="mwBao">int</span><span class="w" id="mwBas"> </span><span class="c" id="mwBaw">(* exceptions can carry a value *)</span> <span class="k" id="mwBa0">let</span><span class="w" id="mwBa4"> </span><span class="nv" id="mwBa8">_</span><span class="w" id="mwBbA"> </span><span class="o" id="mwBbE">=</span> <span class="w" id="mwBbI"> </span><span class="k" id="mwBbM">try</span> <span class="w" id="mwBbQ"> </span><span class="n" id="mwBbU">raise</span><span class="w" id="mwBbY"> </span><span class="o" id="mwBbc">(</span><span class="n" id="mwBbg">MyException</span><span class="w" id="mwBbk"> </span><span class="o" id="mwBbo">(</span><span class="s" id="mwBbs">"not enough food"</span><span class="o" id="mwBbw">,</span><span class="w" id="mwBb0"> </span><span class="mi" id="mwBb4">2</span><span class="o" id="mwBb8">));</span> <span class="w" id="mwBcA"> </span><span class="n" id="mwBcE">printfn</span><span class="w" id="mwBcI"> </span><span class="s" id="mwBcM">"Not reached"</span> <span class="w" id="mwBcQ"> </span><span class="k" id="mwBcU">with</span> <span class="w" id="mwBcY"> </span><span class="o" id="mwBcc">|</span><span class="w" id="mwBcg"> </span><span class="n" id="mwBck">MyException</span><span class="w" id="mwBco"> </span><span class="o" id="mwBcs">(</span><span class="n" id="mwBcw">s</span><span class="o" id="mwBc0">,</span><span class="w" id="mwBc4"> </span><span class="n" id="mwBc8">i</span><span class="o" id="mwBdA">)</span><span class="w" id="mwBdE"> </span><span class="o" id="mwBdI">-></span><span class="w" id="mwBdM"> </span> <span class="w" id="mwBdQ"> </span><span class="n" id="mwBdU">printf</span><span class="w" id="mwBdY"> </span><span class="s" id="mwBdc">"MyException: %s, %d</span><span class="se" id="mwBdg">\n</span><span class="s" id="mwBdk">"</span><span class="w" id="mwBdo"> </span><span class="n" id="mwBds">s</span><span class="w" id="mwBdw"> </span><span class="n" id="mwBd0">i</span> <span class="w" id="mwBd4"> </span><span class="o" id="mwBd8">|</span><span class="w" id="mwBeA"> </span><span class="n" id="mwBeE">e</span><span class="w" id="mwBeI"> </span><span class="o" id="mwBeM">-></span><span class="w" id="mwBeQ"> </span><span class="c" id="mwBeU">(* catch all exceptions *)</span> <span class="w" id="mwBeY"> </span><span class="n" id="mwBec">eprintf</span><span class="w" id="mwBeg"> </span><span class="s" id="mwBek">"Unexpected exception : %O"</span><span class="w" id="mwBeo"> </span><span class="n" id="mwBes">e</span><span class="o" id="mwBew">;</span> <span class="w" id="mwBe0"> </span><span class="n" id="mwBe4">eprintf</span><span class="w" id="mwBe8"> </span><span class="s" id="mwBfA">"%O"</span><span class="w" id="mwBfE"> </span><span class="n" id="mwBfI">e</span><span class="o" id="mwBfM">.</span><span class="n" id="mwBfQ">StackTrace</span>
Haskell
Haskell does not have special syntax for exceptions. Instead, a try/catch/finally/etc. interface is provided by functions.
<span id="mwBgc"></span><span class="kr" id="mwBgg">import</span><span class="w" id="mwBgk"> </span><span class="nn" id="mwBgo">Prelude</span><span class="w" id="mwBgs"> </span><span class="n" id="mwBgw">hiding</span><span class="p" id="mwBg0">(</span><span class="n" id="mwBg4">catch</span><span class="p" id="mwBg8">)</span> <span class="kr" id="mwBhA">import</span><span class="w" id="mwBhE"> </span><span class="nn" id="mwBhI">Control.Exception</span> <span class="kr" id="mwBhM">instance</span><span class="w" id="mwBhQ"> </span><span class="kt" id="mwBhU">Exception</span><span class="w" id="mwBhY"> </span><span class="kt" id="mwBhc">Int</span> <span class="kr" id="mwBhg">instance</span><span class="w" id="mwBhk"> </span><span class="kt" id="mwBho">Exception</span><span class="w" id="mwBhs"> </span><span class="kt" id="mwBhw">Double</span> <span class="nf" id="mwBh0">main</span><span class="w" id="mwBh4"> </span><span class="ow" id="mwBh8">=</span><span class="w" id="mwBiA"> </span><span class="kr" id="mwBiE">do</span> <span class="w" id="mwBiI"> </span><span class="n" id="mwBiM">catch</span> <span class="w" id="mwBiQ"> </span><span class="p" id="mwBiU">(</span><span class="n" id="mwBiY">catch</span> <span class="w" id="mwBic"> </span><span class="p" id="mwBig">(</span><span class="n" id="mwBik">throw</span><span class="w" id="mwBio"> </span><span class="p" id="mwBis">(</span><span class="mi" id="mwBiw">42</span><span class="ow" id="mwBi0">::</span><span class="kt" id="mwBi4">Int</span><span class="p" id="mwBi8">))</span> <span class="w" id="mwBjA"> </span><span class="p" id="mwBjE">(</span><span class="nf" id="mwBjI">\</span><span class="n" id="mwBjM">e</span><span class="ow" id="mwBjQ">-></span><span class="w" id="mwBjU"> </span><span class="n" id="mwBjY">print</span><span class="w" id="mwBjc"> </span><span class="p" id="mwBjg">(</span><span class="mi" id="mwBjk">0</span><span class="p" id="mwBjo">,</span><span class="n" id="mwBjs">e</span><span class="ow" id="mwBjw">::</span><span class="kt" id="mwBj0">Double</span><span class="p" id="mwBj4">)))</span> <span class="w" id="mwBj8"> </span><span class="p" id="mwBkA">(</span><span class="nf" id="mwBkE">\</span><span class="n" id="mwBkI">e</span><span class="ow" id="mwBkM">-></span><span class="w" id="mwBkQ"> </span><span class="n" id="mwBkU">print</span><span class="w" id="mwBkY"> </span><span class="p" id="mwBkc">(</span><span class="mi" id="mwBkg">1</span><span class="p" id="mwBkk">,</span><span class="n" id="mwBko">e</span><span class="ow" id="mwBks">::</span><span class="kt" id="mwBkw">Int</span><span class="p" id="mwBk0">))</span>
prints
(1,42)
in analogy with this C++
<span id="mwBlM"></span><span class="k" id="mwBlQ">import</span><span class="w" id="mwBlU"> </span><span class="n" id="mwBlY">std</span><span class="p" id="mwBlc">;</span> <span class="kt" id="mwBlg">int</span><span class="w" id="mwBlk"> </span><span class="nf" id="mwBlo">main</span><span class="p" id="mwBls">(</span><span class="kt" id="mwBlw">int</span><span class="w" id="mwBl0"> </span><span class="n" id="mwBl4">argc</span><span class="p" id="mwBl8">,</span><span class="w" id="mwBmA"> </span><span class="kt" id="mwBmE">char</span><span class="o" id="mwBmI">*</span><span class="w" id="mwBmM"> </span><span class="n" id="mwBmQ">argv</span><span class="p" id="mwBmU">[])</span><span class="w" id="mwBmY"> </span><span class="p" id="mwBmc">{</span> <span class="w" id="mwBmg"> </span><span class="k" id="mwBmk">try</span><span class="w" id="mwBmo"> </span><span class="p" id="mwBms">{</span> <span class="w" id="mwBmw"> </span><span class="k" id="mwBm0">throw</span><span class="w" id="mwBm4"> </span><span class="k" id="mwBm8">static_cast</span><span class="o" id="mwBnA"><</span><span class="kt" id="mwBnE">int</span><span class="o" id="mwBnI">></span><span class="p" id="mwBnM">(</span><span class="mi" id="mwBnQ">42</span><span class="p" id="mwBnU">);</span> <span class="w" id="mwBnY"> </span><span class="p" id="mwBnc">}</span><span class="w" id="mwBng"> </span><span class="k" id="mwBnk">catch</span><span class="w" id="mwBno"> </span><span class="p" id="mwBns">(</span><span class="kt" id="mwBnw">double</span><span class="w" id="mwBn0"> </span><span class="n" id="mwBn4">d</span><span class="p" id="mwBn8">)</span><span class="w" id="mwBoA"> </span><span class="p" id="mwBoE">{</span> <span class="w" id="mwBoI"> </span><span class="n" id="mwBoM">std</span><span class="o" id="mwBoQ">::</span><span class="n" id="mwBoU">println</span><span class="p" id="mwBoY">(</span><span class="s" id="mwBoc">"(0,{})"</span><span class="p" id="mwBog">,</span><span class="w" id="mwBok"> </span><span class="n" id="mwBoo">d</span><span class="p" id="mwBos">);</span> <span class="w" id="mwBow"> </span><span class="p" id="mwBo0">}</span><span class="w" id="mwBo4"> </span><span class="k" id="mwBo8">catch</span><span class="w" id="mwBpA"> </span><span class="p" id="mwBpE">(</span><span class="kt" id="mwBpI">int</span><span class="w" id="mwBpM"> </span><span class="n" id="mwBpQ">i</span><span class="p" id="mwBpU">)</span><span class="w" id="mwBpY"> </span><span class="p" id="mwBpc">{</span> <span class="w" id="mwBpg"> </span><span class="n" id="mwBpk">std</span><span class="o" id="mwBpo">::</span><span class="n" id="mwBps">println</span><span class="p" id="mwBpw">(</span><span class="s" id="mwBp0">"(1,{})"</span><span class="p" id="mwBp4">,</span><span class="w" id="mwBp8"> </span><span class="n" id="mwBqA">i</span><span class="p" id="mwBqE">);</span> <span class="w" id="mwBqI"> </span><span class="p" id="mwBqM">}</span> <span class="p" id="mwBqQ">}</span>Another example is
<span id="mwBqg"></span><span class="kr" id="mwBqk">do</span><span class="w" id="mwBqo"> </span><span class="p" id="mwBqs">{</span> <span class="w" id="mwBqw"> </span><span class="c1" id="mwBq0">-- Statements in which errors might be thrown</span> <span class="p" id="mwBq4">}</span><span class="w" id="mwBq8"> </span><span class="p" id="mwBrA">`</span><span class="n" id="mwBrE">catch</span><span class="p" id="mwBrI">`</span><span class="w" id="mwBrM"> </span><span class="nf" id="mwBrQ">\</span><span class="n" id="mwBrU">ex</span><span class="w" id="mwBrY"> </span><span class="ow" id="mwBrc">-></span><span class="w" id="mwBrg"> </span><span class="kr" id="mwBrk">do</span><span class="w" id="mwBro"> </span><span class="p" id="mwBrs">{</span> <span class="w" id="mwBrw"> </span><span class="c1" id="mwBr0">-- Statements that execute in the event of an exception, with 'ex' bound to the exception</span> <span class="p" id="mwBr4">}</span>In purely functional code, if only one error condition exists, the Maybe type may be sufficient, and is an instance of Haskell's Monad class by default. More complex error propagation can be achieved using the Error or ErrorT monads, for which similar functionality (using `catch`) is supported.
Java
A try block must have at least one catch or finally clause and at most one finally clause. Java distinguishes between Exceptions (errors reasonable to catch) and Error (errors, usually more severe, unreasonable to catch), both of which are descendants of Throwable (the base class of any object which may be thrown).
<span id="mwBuE"></span><span class="kn" id="mwBuI">package</span><span class="w" id="mwBuM"> </span><span class="nn" id="mwBuQ">org.wikipedia.examples</span><span class="p" id="mwBuU">;</span> <span class="kn" id="mwBuY">import</span><span class="w" id="mwBuc"> </span><span class="nn" id="mwBug">java.io.IOException</span><span class="p" id="mwBuk">;</span> <span class="kd" id="mwBuo">public</span><span class="w" id="mwBus"> </span><span class="kd" id="mwBuw">class</span> <span class="nc" id="mwBu0">Example</span><span class="w" id="mwBu4"> </span><span class="p" id="mwBu8">{</span> <span class="w" id="mwBvA"> </span><span class="kd" id="mwBvE">public</span><span class="w" id="mwBvI"> </span><span class="kd" id="mwBvM">static</span><span class="w" id="mwBvQ"> </span><span class="kt" id="mwBvU">void</span><span class="w" id="mwBvY"> </span><span class="nf" id="mwBvc">main</span><span class="p" id="mwBvg">(</span><span class="n" id="mwBvk">String</span><span class="o" id="mwBvo">[]</span><span class="w" id="mwBvs"> </span><span class="n" id="mwBvw">args</span><span class="p" id="mwBv0">)</span><span class="w" id="mwBv4"> </span><span class="p" id="mwBv8">{</span> <span class="w" id="mwBwA"> </span><span class="k" id="mwBwE">try</span><span class="w" id="mwBwI"> </span><span class="p" id="mwBwM">{</span> <span class="w" id="mwBwQ"> </span><span class="c1" id="mwBwU">// Normal execution path.</span> <span class="w" id="mwBwY"> </span><span class="n" id="mwBwc">mayThrowIOException</span><span class="p" id="mwBwg">();</span><span class="w" id="mwBwk"> </span><span class="c1" id="mwBwo">// method that can throw an IOException</span> <span class="w" id="mwBws"> </span><span class="p" id="mwBww">}</span><span class="w" id="mwBw0"> </span><span class="k" id="mwBw4">catch</span><span class="w" id="mwBw8"> </span><span class="p" id="mwBxA">(</span><span class="n" id="mwBxE">IOException</span><span class="w" id="mwBxI"> </span><span class="n" id="mwBxM">e</span><span class="p" id="mwBxQ">)</span><span class="w" id="mwBxU"> </span><span class="p" id="mwBxY">{</span> <span class="w" id="mwBxc"> </span><span class="c1" id="mwBxg">// Deal with the IOException.</span> <span class="w" id="mwBxk"> </span><span class="c1" id="mwBxo">// IOException is a checked exception that must be caught.</span> <span class="w" id="mwBxs"> </span><span class="p" id="mwBxw">}</span><span class="w" id="mwBx0"> </span><span class="k" id="mwBx4">catch</span><span class="w" id="mwBx8"> </span><span class="p" id="mwByA">(</span><span class="n" id="mwByE">RuntimeException</span><span class="w" id="mwByI"> </span><span class="n" id="mwByM">e</span><span class="p" id="mwByQ">)</span><span class="w" id="mwByU"> </span><span class="p" id="mwByY">{</span> <span class="w" id="mwByc"> </span><span class="c1" id="mwByg">// Deal with the RuntimeException.</span> <span class="w" id="mwByk"> </span><span class="c1" id="mwByo">// Runtime exceptions are unchecked, and are not forced to be caught.</span> <span class="w" id="mwBys"> </span><span class="p" id="mwByw">}</span><span class="w" id="mwBy0"> </span><span class="k" id="mwBy4">catch</span><span class="w" id="mwBy8"> </span><span class="p" id="mwBzA">(</span><span class="n" id="mwBzE">Exception</span><span class="w" id="mwBzI"> </span><span class="n" id="mwBzM">e</span><span class="p" id="mwBzQ">)</span><span class="w" id="mwBzU"> </span><span class="p" id="mwBzY">{</span> <span class="w" id="mwBzc"> </span><span class="c1" id="mwBzg">// Catches anything that is an instance of Exception</span> <span class="w" id="mwBzk"> </span><span class="p" id="mwBzo">}</span><span class="w" id="mwBzs"> </span><span class="k" id="mwBzw">catch</span><span class="w" id="mwBz0"> </span><span class="p" id="mwBz4">(</span><span class="n" id="mwBz8">Throwable</span><span class="w" id="mwB0A"> </span><span class="n" id="mwB0E">t</span><span class="p" id="mwB0I">)</span><span class="w" id="mwB0M"> </span><span class="p" id="mwB0Q">{</span> <span class="w" id="mwB0U"> </span><span class="c1" id="mwB0Y">// Catches anything that is an instance of Throwable (including both Exception and Error)</span> <span class="w" id="mwB0c"> </span><span class="p" id="mwB0g">}</span><span class="w" id="mwB0k"> </span><span class="k" id="mwB0o">finally</span><span class="w" id="mwB0s"> </span><span class="p" id="mwB0w">{</span> <span class="w" id="mwB00"> </span><span class="c1" id="mwB04">// Always run when leaving the try block (including finally clauses), regardless of whether any exceptions were thrown or whether they were handled.</span> <span class="w" id="mwB08"> </span><span class="c1" id="mwB1A">// Cleans up and closes resources acquired in the try block.</span> <span class="w" id="mwB1E"> </span><span class="c1" id="mwB1I">// May not be run when System.exit() is called and in other system-wide exceptional conditions (e.g. power loss).</span> <span class="w" id="mwB1M"> </span><span class="c1" id="mwB1Q">// Rarely used after try-with-resources was added to the language (see below).</span> <span class="w" id="mwB1U"> </span><span class="p" id="mwB1Y">}</span> <span class="w" id="mwB1c"> </span><span class="p" id="mwB1g">}</span> <span class="p" id="mwB1k">}</span>If multiple resources are acquired, the correct way to deal with them is with nested try blocks. For this reason and others, try-with-resources was added to the language to almost entirely replace finally clauses. Resources acquired in a parentheses after the try keyword will be cleaned up automatically. Classes used in these statements must implement an interface called java.lang.AutoCloseable. This is similar to the "resource acquisition is initialization" pattern common in languages like C++, where resources are cleaned after leaving scope.
<span id="mwB2k"></span><span class="kn" id="mwB2o">package</span><span class="w" id="mwB2s"> </span><span class="nn" id="mwB2w">org.wikipedia.examples</span><span class="p" id="mwB20">;</span> <span class="kn" id="mwB24">import</span><span class="w" id="mwB28"> </span><span class="nn" id="mwB3A">java.io.BufferedReader</span><span class="p" id="mwB3E">;</span> <span class="kn" id="mwB3I">import</span><span class="w" id="mwB3M"> </span><span class="nn" id="mwB3Q">java.io.FileReader</span><span class="p" id="mwB3U">;</span> <span class="kn" id="mwB3Y">import</span><span class="w" id="mwB3c"> </span><span class="nn" id="mwB3g">java.io.IOException</span><span class="p" id="mwB3k">;</span> <span class="kd" id="mwB3o">public</span><span class="w" id="mwB3s"> </span><span class="kd" id="mwB3w">class</span> <span class="nc" id="mwB30">Example</span><span class="w" id="mwB34"> </span><span class="p" id="mwB38">{</span> <span class="w" id="mwB4A"> </span><span class="kd" id="mwB4E">public</span><span class="w" id="mwB4I"> </span><span class="kd" id="mwB4M">static</span><span class="w" id="mwB4Q"> </span><span class="kt" id="mwB4U">void</span><span class="w" id="mwB4Y"> </span><span class="nf" id="mwB4c">main</span><span class="p" id="mwB4g">(</span><span class="n" id="mwB4k">String</span><span class="o" id="mwB4o">[]</span><span class="w" id="mwB4s"> </span><span class="n" id="mwB4w">args</span><span class="p" id="mwB40">)</span><span class="w" id="mwB44"> </span><span class="p" id="mwB48">{</span> <span class="w" id="mwB5A"> </span><span class="k" id="mwB5E">try</span><span class="w" id="mwB5I"> </span><span class="p" id="mwB5M">(</span><span class="n" id="mwB5Q">FileReader</span><span class="w" id="mwB5U"> </span><span class="n" id="mwB5Y">fr</span><span class="w" id="mwB5c"> </span><span class="o" id="mwB5g">=</span><span class="w" id="mwB5k"> </span><span class="k" id="mwB5o">new</span><span class="w" id="mwB5s"> </span><span class="n" id="mwB5w">FileReader</span><span class="p" id="mwB50">(</span><span class="n" id="mwB54">path</span><span class="p" id="mwB58">);</span><span class="w" id="mwB6A"> </span><span class="n" id="mwB6E">BufferedReader</span><span class="w" id="mwB6I"> </span><span class="n" id="mwB6M">br</span><span class="w" id="mwB6Q"> </span><span class="o" id="mwB6U">=</span><span class="w" id="mwB6Y"> </span><span class="k" id="mwB6c">new</span><span class="w" id="mwB6g"> </span><span class="n" id="mwB6k">BufferedReader</span><span class="p" id="mwB6o">(</span><span class="n" id="mwB6s">fr</span><span class="p" id="mwB6w">))</span><span class="w" id="mwB60"> </span><span class="p" id="mwB64">{</span> <span class="w" id="mwB68"> </span><span class="c1" id="mwB7A">// Normal execution path.</span> <span class="w" id="mwB7E"> </span><span class="p" id="mwB7I">}</span><span class="w" id="mwB7M"> </span><span class="k" id="mwB7Q">catch</span><span class="w" id="mwB7U"> </span><span class="p" id="mwB7Y">(</span><span class="n" id="mwB7c">IOException</span><span class="w" id="mwB7g"> </span><span class="n" id="mwB7k">e</span><span class="p" id="mwB7o">)</span><span class="w" id="mwB7s"> </span><span class="p" id="mwB7w">{</span><span class="w" id="mwB70"> </span> <span class="w" id="mwB74"> </span><span class="c1" id="mwB78">// Deal with exception.</span> <span class="w" id="mwB8A"> </span><span class="c1" id="mwB8E">// Resources in the try statement are automatically closed afterwards.</span> <span class="w" id="mwB8I"> </span><span class="p" id="mwB8M">}</span><span class="w" id="mwB8Q"> </span><span class="k" id="mwB8U">finally</span><span class="w" id="mwB8Y"> </span><span class="p" id="mwB8c">{</span> <span class="w" id="mwB8g"> </span><span class="c1" id="mwB8k">// A finally clause can be included, and will run after the resources in the try statements are closed.</span> <span class="w" id="mwB8o"> </span><span class="p" id="mwB8s">}</span> <span class="w" id="mwB8w"> </span><span class="p" id="mwB80">}</span> <span class="p" id="mwB84">}</span>JavaScript
The design of JavaScript makes loud/hard errors very uncommon. Soft/quiet errors are much more prevalent. Hard errors propagate to the nearest try statement, which must be followed by either a single catch clause, a single finally clause, or both.
<span id="mwB9o"></span><span class="k" id="mwB9s">try</span><span class="w" id="mwB9w"> </span><span class="p" id="mwB90">{</span> <span class="w" id="mwB94"> </span><span class="c1" id="mwB98">// Statements in which exceptions might be thrown</span> <span class="w" id="mwB-A"> </span><span class="k" id="mwB-E">throw</span><span class="w" id="mwB-I"> </span><span class="ow" id="mwB-M">new</span><span class="w" id="mwB-Q"> </span><span class="ne" id="mwB-U">Error</span><span class="p" id="mwB-Y">(</span><span class="s2" id="mwB-c">"error"</span><span class="p" id="mwB-g">);</span> <span class="p" id="mwB-k">}</span><span class="w" id="mwB-o"> </span><span class="k" id="mwB-s">catch</span><span class="w" id="mwB-w"> </span><span class="p" id="mwB-0">(</span><span class="nx" id="mwB-4">error</span><span class="p" id="mwB-8">)</span><span class="w" id="mwB_A"> </span><span class="p" id="mwB_E">{</span> <span class="w" id="mwB_I"> </span><span class="c1" id="mwB_M">// Statements that execute in the event of an exception</span> <span class="p" id="mwB_Q">}</span><span class="w" id="mwB_U"> </span><span class="k" id="mwB_Y">finally</span><span class="w" id="mwB_c"> </span><span class="p" id="mwB_g">{</span> <span class="w" id="mwB_k"> </span><span class="c1" id="mwB_o">// Statements that execute afterward either way</span> <span class="p" id="mwB_s">}</span>If there is no try statement at all, then the webpage does not crash. Rather, an error is logged to the console and the stack is cleared. However, JavaScript has the interesting quirk of asynchronous externally-invoked entry points. Whereas, in most other languages, there is always some part of the code running at all times, JavaScript does not have to run linearly from start to end. For example, event listeners, Promises, and timers can be invoked by the browser at a later point in time and run in an isolated but shared context with the rest of the code. Observe how the code below will throw a new error every 4 seconds for an indefinite period of time or until the browser/tab/computer is closed.
<span id="mwCAA"></span><span class="nx" id="mwCAE">setInterval</span><span class="p" id="mwCAI">(</span><span class="kd" id="mwCAM">function</span><span class="p" id="mwCAQ">()</span><span class="w" id="mwCAU"> </span><span class="p" id="mwCAY">{</span> <span class="w" id="mwCAc"> </span><span class="k" id="mwCAg">throw</span><span class="w" id="mwCAk"> </span><span class="ow" id="mwCAo">new</span><span class="w" id="mwCAs"> </span><span class="ne" id="mwCAw">Error</span><span class="p" id="mwCA0">(</span><span class="s2" id="mwCA4">"Example of an error thrown on a 4 second interval."</span><span class="p" id="mwCA8">);</span> <span class="p" id="mwCBA">},</span><span class="w" id="mwCBE"> </span><span class="mf" id="mwCBI">4000</span><span class="p" id="mwCBM">);</span>Another interesting quirk is polymorphism: JavaScript can throw primitive values as errors.
<span id="mwCBc"></span><span class="k" id="mwCBg">try</span><span class="w" id="mwCBk"> </span><span class="p" id="mwCBo">{</span> <span class="w" id="mwCBs"> </span><span class="k" id="mwCBw">throw</span><span class="w" id="mwCB0"> </span><span class="mf" id="mwCB4">12345</span><span class="p" id="mwCB8">;</span><span class="w" id="mwCCA"> </span><span class="c1" id="mwCCE">// primitive number</span> <span class="p" id="mwCCI">}</span><span class="w" id="mwCCM"> </span><span class="k" id="mwCCQ">catch</span><span class="w" id="mwCCU"> </span><span class="p" id="mwCCY">(</span><span class="nx" id="mwCCc">error</span><span class="p" id="mwCCg">)</span><span class="w" id="mwCCk"> </span><span class="p" id="mwCCo">{</span> <span class="w" id="mwCCs"> </span><span class="nx" id="mwCCw">console</span><span class="p" id="mwCC0">.</span><span class="nx" id="mwCC4">log</span><span class="p" id="mwCC8">(</span><span class="nx" id="mwCDA">error</span><span class="p" id="mwCDE">);</span><span class="w" id="mwCDI"> </span><span class="c1" id="mwCDM">// logs 12345 as a primitive number to the console</span> <span class="p" id="mwCDQ">}</span>Note that the catch clause is a catch-all, which catches every type of error. There is no syntaxical ability to assign different handlers to different error types aside from experimental and presently removed Gecko extensions from many years ago. Instead, one can either propagate the error by using a throw statement inside the catch statement, or use multiple conditional cases. Let us compare an example in Java and its rough equivalents in JavaScript.
<span id="mwCDs"></span><span class="c1" id="mwCDw">// Example in Java</span> <span class="k" id="mwCD0">try</span><span class="w" id="mwCD4"> </span><span class="p" id="mwCD8">{</span> <span class="w" id="mwCEA"> </span><span class="n" id="mwCEE">Integer</span><span class="w" id="mwCEI"> </span><span class="n" id="mwCEM">i</span><span class="w" id="mwCEQ"> </span><span class="o" id="mwCEU">=</span><span class="w" id="mwCEY"> </span><span class="kc" id="mwCEc">null</span><span class="p" id="mwCEg">;</span> <span class="w" id="mwCEk"> </span><span class="n" id="mwCEo">i</span><span class="p" id="mwCEs">.</span><span class="na" id="mwCEw">intValue</span><span class="p" id="mwCE0">();</span><span class="w" id="mwCE4"> </span><span class="c1" id="mwCE8">// throws a NullPointerException</span> <span class="p" id="mwCFA">}</span><span class="w" id="mwCFE"> </span><span class="k" id="mwCFI">catch</span><span class="w" id="mwCFM"> </span><span class="p" id="mwCFQ">(</span><span class="n" id="mwCFU">NullPointerException</span><span class="w" id="mwCFY"> </span><span class="n" id="mwCFc">error</span><span class="p" id="mwCFg">)</span><span class="w" id="mwCFk"> </span><span class="p" id="mwCFo">{</span> <span class="w" id="mwCFs"> </span><span class="c1" id="mwCFw">// Variable might be null</span> <span class="p" id="mwCF0">}</span><span class="w" id="mwCF4"> </span><span class="k" id="mwCF8">catch</span><span class="w" id="mwCGA"> </span><span class="p" id="mwCGE">(</span><span class="n" id="mwCGI">ArithmeticException</span><span class="w" id="mwCGM"> </span><span class="n" id="mwCGQ">error</span><span class="p" id="mwCGU">)</span><span class="w" id="mwCGY"> </span><span class="p" id="mwCGc">{</span> <span class="w" id="mwCGg"> </span><span class="c1" id="mwCGk">// Handle problems with numbers</span> <span class="p" id="mwCGo">}</span><span id="mwCG0"></span><span class="c1" id="mwCG4">// Approximation #1 in JavaScript</span> <span class="k" id="mwCG8">try</span><span class="w" id="mwCHA"> </span><span class="p" id="mwCHE">{</span> <span class="w" id="mwCHI"> </span><span class="c1" id="mwCHM">// Statements in which exceptions might be thrown</span> <span class="w" id="mwCHQ"> </span><span class="kd" id="mwCHU">let</span><span class="w" id="mwCHY"> </span><span class="nx" id="mwCHc">example</span><span class="w" id="mwCHg"> </span><span class="o" id="mwCHk">=</span><span class="w" id="mwCHo"> </span><span class="kc" id="mwCHs">null</span><span class="p" id="mwCHw">;</span> <span class="w" id="mwCH0"> </span><span class="nx" id="mwCH4">example</span><span class="p" id="mwCH8">.</span><span class="nx" id="mwCIA">toString</span><span class="p" id="mwCIE">();</span> <span class="p" id="mwCII">}</span><span class="w" id="mwCIM"> </span><span class="k" id="mwCIQ">catch</span><span class="w" id="mwCIU"> </span><span class="p" id="mwCIY">(</span><span class="nx" id="mwCIc">error</span><span class="p" id="mwCIg">)</span><span class="w" id="mwCIk"> </span><span class="p" id="mwCIo">{</span> <span class="w" id="mwCIs"> </span><span class="k" id="mwCIw">if</span><span class="w" id="mwCI0"> </span><span class="p" id="mwCI4">(</span><span class="nx" id="mwCI8">error</span><span class="p" id="mwCJA">.</span><span class="nx" id="mwCJE">type</span><span class="w" id="mwCJI"> </span><span class="o" id="mwCJM">===</span><span class="w" id="mwCJQ"> </span><span class="s2" id="mwCJU">"TypeError"</span><span class="p" id="mwCJY">)</span><span class="w" id="mwCJc"> </span><span class="p" id="mwCJg">{</span> <span class="w" id="mwCJk"> </span><span class="c1" id="mwCJo">// Variable might be null</span> <span class="w" id="mwCJs"> </span><span class="p" id="mwCJw">}</span><span class="w" id="mwCJ0"> </span><span class="k" id="mwCJ4">else</span><span class="w" id="mwCJ8"> </span><span class="k" id="mwCKA">if</span><span class="w" id="mwCKE"> </span><span class="p" id="mwCKI">(</span><span class="nx" id="mwCKM">error</span><span class="p" id="mwCKQ">.</span><span class="nx" id="mwCKU">type</span><span class="w" id="mwCKY"> </span><span class="o" id="mwCKc">===</span><span class="w" id="mwCKg"> </span><span class="s2" id="mwCKk">"RangeError"</span><span class="p" id="mwCKo">)</span><span class="w" id="mwCKs"> </span><span class="p" id="mwCKw">{</span> <span class="w" id="mwCK0"> </span><span class="c1" id="mwCK4">// Handle problems with numbers</span> <span class="w" id="mwCK8"> </span><span class="p" id="mwCLA">}</span> <span class="p" id="mwCLE">}</span><span id="mwCLQ"></span><span class="c1" id="mwCLU">// Approximation #2 in JavaScript</span> <span class="k" id="mwCLY">try</span><span class="w" id="mwCLc"> </span><span class="p" id="mwCLg">{</span> <span class="w" id="mwCLk"> </span><span class="k" id="mwCLo">try</span><span class="w" id="mwCLs"> </span><span class="p" id="mwCLw">{</span> <span class="w" id="mwCL0"> </span><span class="c1" id="mwCL4">// Statements in which exceptions might be thrown</span> <span class="w" id="mwCL8"> </span><span class="kd" id="mwCMA">let</span><span class="w" id="mwCME"> </span><span class="nx" id="mwCMI">example</span><span class="w" id="mwCMM"> </span><span class="o" id="mwCMQ">=</span><span class="w" id="mwCMU"> </span><span class="kc" id="mwCMY">null</span><span class="p" id="mwCMc">;</span> <span class="w" id="mwCMg"> </span><span class="nx" id="mwCMk">example</span><span class="p" id="mwCMo">.</span><span class="nx" id="mwCMs">toString</span><span class="p" id="mwCMw">();</span> <span class="w" id="mwCM0"> </span><span class="p" id="mwCM4">}</span><span class="w" id="mwCM8"> </span><span class="k" id="mwCNA">catch</span><span class="w" id="mwCNE"> </span><span class="p" id="mwCNI">(</span><span class="nx" id="mwCNM">error</span><span class="p" id="mwCNQ">)</span><span class="w" id="mwCNU"> </span><span class="p" id="mwCNY">{</span> <span class="w" id="mwCNc"> </span><span class="k" id="mwCNg">if</span><span class="w" id="mwCNk"> </span><span class="p" id="mwCNo">(</span><span class="nx" id="mwCNs">error</span><span class="p" id="mwCNw">.</span><span class="nx" id="mwCN0">type</span><span class="w" id="mwCN4"> </span><span class="o" id="mwCN8">!==</span><span class="w" id="mwCOA"> </span><span class="s2" id="mwCOE">"TypeError"</span><span class="p" id="mwCOI">)</span><span class="w" id="mwCOM"> </span><span class="k" id="mwCOQ">throw</span><span class="w" id="mwCOU"> </span><span class="nx" id="mwCOY">error</span><span class="p" id="mwCOc">;</span> <span class="w" id="mwCOg"> </span><span class="c1" id="mwCOk">// Variable might be null</span> <span class="w" id="mwCOo"> </span><span class="p" id="mwCOs">}</span> <span class="p" id="mwCOw">}</span><span class="w" id="mwCO0"> </span><span class="k" id="mwCO4">catch</span><span class="w" id="mwCO8"> </span><span class="p" id="mwCPA">(</span><span class="nx" id="mwCPE">error</span><span class="p" id="mwCPI">)</span><span class="w" id="mwCPM"> </span><span class="p" id="mwCPQ">{</span> <span class="w" id="mwCPU"> </span><span class="k" id="mwCPY">if</span><span class="w" id="mwCPc"> </span><span class="p" id="mwCPg">(</span><span class="nx" id="mwCPk">error</span><span class="p" id="mwCPo">.</span><span class="nx" id="mwCPs">type</span><span class="w" id="mwCPw"> </span><span class="o" id="mwCP0">!==</span><span class="w" id="mwCP4"> </span><span class="s2" id="mwCP8">"RangeError"</span><span class="p" id="mwCQA">)</span><span class="w" id="mwCQE"> </span><span class="k" id="mwCQI">throw</span><span class="w" id="mwCQM"> </span><span class="nx" id="mwCQQ">error</span><span class="p" id="mwCQU">;</span> <span class="w" id="mwCQY"> </span><span class="c1" id="mwCQc">// Handle problems with numbers</span> <span class="p" id="mwCQg">}</span>Another aspect of exceptions are promises, which handle the exception asynchronously. Handling the exception asynchronously has the benefit that errors inside the error handler do not propagate further outwards.
<span id="mwCQw"></span><span class="ow" id="mwCQ0">new</span><span class="w" id="mwCQ4"> </span><span class="nb" id="mwCQ8">Promise</span><span class="p" id="mwCRA">(</span><span class="kd" id="mwCRE">function</span><span class="p" id="mwCRI">()</span><span class="w" id="mwCRM"> </span><span class="p" id="mwCRQ">{</span> <span class="w" id="mwCRU"> </span><span class="k" id="mwCRY">throw</span><span class="w" id="mwCRc"> </span><span class="ow" id="mwCRg">new</span><span class="w" id="mwCRk"> </span><span class="ne" id="mwCRo">Error</span><span class="p" id="mwCRs">(</span><span class="s2" id="mwCRw">"Example error!"</span><span class="p" id="mwCR0">);</span> <span class="p" id="mwCR4">}).</span><span class="k" id="mwCR8">catch</span><span class="p" id="mwCSA">(</span><span class="kd" id="mwCSE">function</span><span class="p" id="mwCSI">(</span><span class="nx" id="mwCSM">err</span><span class="p" id="mwCSQ">)</span><span class="w" id="mwCSU"> </span><span class="p" id="mwCSY">{</span> <span class="w" id="mwCSc"> </span><span class="nx" id="mwCSg">console</span><span class="p" id="mwCSk">.</span><span class="nx" id="mwCSo">log</span><span class="p" id="mwCSs">(</span><span class="s2" id="mwCSw">"Caught "</span><span class="p" id="mwCS0">,</span><span class="w" id="mwCS4"> </span><span class="nx" id="mwCS8">err</span><span class="p" id="mwCTA">);</span> <span class="p" id="mwCTE">});</span>Also observe how event handlers can tie into promises as well.
<span id="mwCTU"></span><span class="nx" id="mwCTY">addEventListener</span><span class="p" id="mwCTc">(</span><span class="s2" id="mwCTg">"unhandledrejection"</span><span class="p" id="mwCTk">,</span><span class="w" id="mwCTo"> </span><span class="kd" id="mwCTs">function</span><span class="p" id="mwCTw">(</span><span class="nx" id="mwCT0">event</span><span class="p" id="mwCT4">)</span><span class="w" id="mwCT8"> </span><span class="p" id="mwCUA">{</span> <span class="w" id="mwCUE"> </span><span class="nx" id="mwCUI">console</span><span class="p" id="mwCUM">.</span><span class="nx" id="mwCUQ">log</span><span class="p" id="mwCUU">(</span><span class="nx" id="mwCUY">event</span><span class="p" id="mwCUc">.</span><span class="nx" id="mwCUg">reason</span><span class="p" id="mwCUk">);</span> <span class="w" id="mwCUo"> </span><span class="nx" id="mwCUs">event</span><span class="p" id="mwCUw">.</span><span class="nx" id="mwCU0">preventDefault</span><span class="p" id="mwCU4">();</span><span class="w" id="mwCU8"> </span><span class="c1" id="mwCVA">//prevent logging the error via console.error to the console--the default behavior</span> <span class="p" id="mwCVE">});</span> <span class="ow" id="mwCVI">new</span><span class="w" id="mwCVM"> </span><span class="nb" id="mwCVQ">Promise</span><span class="p" id="mwCVU">(</span><span class="kd" id="mwCVY">function</span><span class="p" id="mwCVc">()</span><span class="w" id="mwCVg"> </span><span class="p" id="mwCVk">{</span> <span class="w" id="mwCVo"> </span><span class="k" id="mwCVs">throw</span><span class="w" id="mwCVw"> </span><span class="ow" id="mwCV0">new</span><span class="w" id="mwCV4"> </span><span class="ne" id="mwCV8">Error</span><span class="p" id="mwCWA">(</span><span class="s2" id="mwCWE">"Example error!"</span><span class="p" id="mwCWI">);</span> <span class="p" id="mwCWM">});</span>Lastly, note that, as JavaScript uses mark-and-sweep garbage-collection, there is never any memory leakage from throw statements because the browser automatically cleans dead objects—even with circular references.
<span id="mwCWg"></span><span class="k" id="mwCWk">try</span><span class="w" id="mwCWo"> </span><span class="p" id="mwCWs">{</span> <span class="w" id="mwCWw"> </span><span class="c1" id="mwCW0">// Statements in which exceptions might be thrown</span> <span class="w" id="mwCW4"> </span><span class="kd" id="mwCW8">const</span><span class="w" id="mwCXA"> </span><span class="nx" id="mwCXE">obj</span><span class="w" id="mwCXI"> </span><span class="o" id="mwCXM">=</span><span class="w" id="mwCXQ"> </span><span class="p" id="mwCXU">{};</span> <span class="w" id="mwCXY"> </span><span class="nx" id="mwCXc">obj</span><span class="p" id="mwCXg">.</span><span class="nx" id="mwCXk">selfPropExample</span><span class="w" id="mwCXo"> </span><span class="o" id="mwCXs">=</span><span class="w" id="mwCXw"> </span><span class="nx" id="mwCX0">obj</span><span class="p" id="mwCX4">;</span><span class="w" id="mwCX8"> </span><span class="c1" id="mwCYA">// circular reference</span> <span class="w" id="mwCYE"> </span><span class="k" id="mwCYI">throw</span><span class="w" id="mwCYM"> </span><span class="nx" id="mwCYQ">obj</span><span class="p" id="mwCYU">;</span> <span class="p" id="mwCYY">}</span><span class="w" id="mwCYc"> </span><span class="k" id="mwCYg">catch</span><span class="w" id="mwCYk"> </span><span class="p" id="mwCYo">(</span><span class="nx" id="mwCYs">error</span><span class="p" id="mwCYw">)</span><span class="w" id="mwCY0"> </span><span class="p" id="mwCY4">{</span> <span class="w" id="mwCY8"> </span><span class="c1" id="mwCZA">// Statements that execute in the event of an exception</span> <span class="p" id="mwCZE">}</span>TypeScript
In TypeScript, catch blocks cannot specify types, but this is traditionally done using instanceof. The only type annotation that can be given to the caught exception is unknown.
<span id="mwCZw"></span><span class="k" id="mwCZ0">try</span><span class="w" id="mwCZ4"> </span><span class="p" id="mwCZ8">{</span> <span class="w" id="mwCaA"> </span><span class="c1" id="mwCaE">// ...</span> <span class="p" id="mwCaI">}</span><span class="w" id="mwCaM"> </span><span class="k" id="mwCaQ">catch</span><span class="w" id="mwCaU"> </span><span class="p" id="mwCaY">(</span><span class="nx" id="mwCac">e</span><span class="o" id="mwCag">:</span><span class="w" id="mwCak"> </span><span class="kt" id="mwCao">unknown</span><span class="p" id="mwCas">)</span><span class="w" id="mwCaw"> </span><span class="p" id="mwCa0">{</span> <span class="w" id="mwCa4"> </span><span class="k" id="mwCa8">if</span><span class="w" id="mwCbA"> </span><span class="p" id="mwCbE">(</span><span class="nx" id="mwCbI">e</span><span class="w" id="mwCbM"> </span><span class="ow" id="mwCbQ">instanceof</span><span class="w" id="mwCbU"> </span><span class="ne" id="mwCbY">TypeError</span><span class="p" id="mwCbc">)</span><span class="w" id="mwCbg"> </span><span class="p" id="mwCbk">{</span> <span class="w" id="mwCbo"> </span><span class="c1" id="mwCbs">// handle errors of type TypeError</span> <span class="w" id="mwCbw"> </span><span class="p" id="mwCb0">}</span><span class="w" id="mwCb4"> </span><span class="k" id="mwCb8">else</span><span class="w" id="mwCcA"> </span><span class="k" id="mwCcE">if</span><span class="w" id="mwCcI"> </span><span class="p" id="mwCcM">(</span><span class="nx" id="mwCcQ">e</span><span class="w" id="mwCcU"> </span><span class="ow" id="mwCcY">instanceof</span><span class="w" id="mwCcc"> </span><span class="ne" id="mwCcg">SyntaxError</span><span class="p" id="mwCck">)</span><span class="w" id="mwCco"> </span><span class="p" id="mwCcs">{</span> <span class="w" id="mwCcw"> </span><span class="c1" id="mwCc0">// handle errors of type SyntaxError</span> <span class="w" id="mwCc4"> </span><span class="p" id="mwCc8">}</span><span class="w" id="mwCdA"> </span><span class="k" id="mwCdE">else</span><span class="w" id="mwCdI"> </span><span class="k" id="mwCdM">if</span><span class="w" id="mwCdQ"> </span><span class="p" id="mwCdU">(</span><span class="nx" id="mwCdY">e</span><span class="w" id="mwCdc"> </span><span class="ow" id="mwCdg">instanceof</span><span class="w" id="mwCdk"> </span><span class="ne" id="mwCdo">Error</span><span class="p" id="mwCds">)</span><span class="w" id="mwCdw"> </span><span class="p" id="mwCd0">{</span> <span class="w" id="mwCd4"> </span><span class="c1" id="mwCd8">// handle errors that extend Error</span> <span class="w" id="mwCeA"> </span><span class="p" id="mwCeE">}</span><span class="w" id="mwCeI"> </span><span class="k" id="mwCeM">else</span><span class="w" id="mwCeQ"> </span><span class="p" id="mwCeU">{</span> <span class="w" id="mwCeY"> </span><span class="c1" id="mwCec">// handle any thrown object</span> <span class="w" id="mwCeg"> </span><span class="p" id="mwCek">}</span> <span class="p" id="mwCeo">}</span><span class="w" id="mwCes"> </span><span class="k" id="mwCew">finally</span><span class="w" id="mwCe0"> </span><span class="p" id="mwCe4">{</span> <span class="w" id="mwCe8"> </span><span class="c1" id="mwCfA">// ...</span> <span class="p" id="mwCfE">}</span>Kotlin
Kotlin error handling syntax is very similar to Java.
<span id="mwCfk"></span><span class="k" id="mwCfo">try</span><span class="w" id="mwCfs"> </span><span class="p" id="mwCfw">{</span> <span class="w" id="mwCf0"> </span><span class="c1" id="mwCf4">// Code that may throw an exception</span> <span class="p" id="mwCf8">}</span><span class="w" id="mwCgA"> </span><span class="k" id="mwCgE">catch</span><span class="w" id="mwCgI"> </span><span class="p" id="mwCgM">(</span><span class="n" id="mwCgQ">e</span><span class="p" id="mwCgU">:</span><span class="w" id="mwCgY"> </span><span class="n" id="mwCgc">ArithmeticException</span><span class="p" id="mwCgg">)</span><span class="w" id="mwCgk"> </span><span class="p" id="mwCgo">{</span> <span class="w" id="mwCgs"> </span><span class="c1" id="mwCgw">// Code for handling a kotlin.ArithmeticException</span> <span class="w" id="mwCg0"> </span><span class="c1" id="mwCg4">// (translates to java.lang.ArithmeticException)</span> <span class="p" id="mwCg8">}</span><span class="w" id="mwChA"> </span><span class="k" id="mwChE">catch</span><span class="w" id="mwChI"> </span><span class="p" id="mwChM">(</span><span class="n" id="mwChQ">e</span><span class="p" id="mwChU">:</span><span class="w" id="mwChY"> </span><span class="n" id="mwChc">Exception</span><span class="p" id="mwChg">)</span><span class="w" id="mwChk"> </span><span class="p" id="mwCho">{</span> <span class="w" id="mwChs"> </span><span class="c1" id="mwChw">// Catches anything extending kotlin.Exception</span> <span class="w" id="mwCh0"> </span><span class="c1" id="mwCh4">// (translates to java.lang.Exception)</span> <span class="p" id="mwCh8">}</span><span class="w" id="mwCiA"> </span><span class="k" id="mwCiE">catch</span><span class="w" id="mwCiI"> </span><span class="p" id="mwCiM">(</span><span class="n" id="mwCiQ">t</span><span class="p" id="mwCiU">:</span><span class="w" id="mwCiY"> </span><span class="n" id="mwCic">Throwable</span><span class="p" id="mwCig">)</span><span class="w" id="mwCik"> </span><span class="p" id="mwCio">{</span> <span class="w" id="mwCis"> </span><span class="c1" id="mwCiw">// Catches anything extending kotlin.Throwable</span> <span class="w" id="mwCi0"> </span><span class="c1" id="mwCi4">// (translates to java.lang.Throwable)</span> <span class="p" id="mwCi8">}</span><span class="w" id="mwCjA"> </span><span class="k" id="mwCjE">finally</span><span class="w" id="mwCjI"> </span><span class="p" id="mwCjM">{</span> <span class="w" id="mwCjQ"> </span><span class="c1" id="mwCjU">// Finally clause</span> <span class="p" id="mwCjY">}</span>Kotlin does not force catching checked exceptions, but can still force Java callers to catch/declare the checked exception.
<span id="mwCjo"></span><span class="k" id="mwCjs">import</span><span class="w" id="mwCjw"> </span><span class="nn" id="mwCj0">java.io.IOException</span> <span class="nd" id="mwCj4">@Throws</span><span class="p" id="mwCj8">(</span><span class="n" id="mwCkA">IOException</span><span class="o" id="mwCkE">::</span><span class="n" id="mwCkI">class</span><span class="p" id="mwCkM">)</span> <span class="kd" id="mwCkQ">fun</span><span class="w" id="mwCkU"> </span><span class="nf" id="mwCkY">readFile</span><span class="p" id="mwCkc">()</span><span class="w" id="mwCkg"> </span><span class="p" id="mwCkk">{</span> <span class="w" id="mwCko"> </span><span class="c1" id="mwCks">// ...</span> <span class="w" id="mwCkw"> </span><span class="k" id="mwCk0">throw</span><span class="w" id="mwCk4"> </span><span class="n" id="mwCk8">IOException</span><span class="p" id="mwClA">(</span><span class="s" id="mwClE">"Failed to read file!"</span><span class="p" id="mwClI">)</span> <span class="p" id="mwClM">}</span> <span class="c1" id="mwClQ">// translates into</span> <span class="c1" id="mwClU">// public static void readFile() throws IOException;</span> <span class="c1" id="mwClY">// in the JVM</span>Kotlin supports try-expressions:
<span id="mwCls"></span><span class="kd" id="mwClw">val</span><span class="w" id="mwCl0"> </span><span class="nv" id="mwCl4">result</span><span class="p" id="mwCl8">:</span><span class="w" id="mwCmA"> </span><span class="kt" id="mwCmE">Int</span><span class="w" id="mwCmI"> </span><span class="o" id="mwCmM">=</span><span class="w" id="mwCmQ"> </span><span class="k" id="mwCmU">try</span><span class="w" id="mwCmY"> </span><span class="p" id="mwCmc">{</span> <span class="w" id="mwCmg"> </span><span class="s" id="mwCmk">"123"</span><span class="p" id="mwCmo">.</span><span class="na" id="mwCms">toInt</span><span class="p" id="mwCmw">()</span><span class="w" id="mwCm0"> </span><span class="c1" id="mwCm4">// result gets 123</span> <span class="p" id="mwCm8">}</span><span class="w" id="mwCnA"> </span><span class="k" id="mwCnE">catch</span><span class="w" id="mwCnI"> </span><span class="p" id="mwCnM">(</span><span class="n" id="mwCnQ">e</span><span class="p" id="mwCnU">:</span><span class="w" id="mwCnY"> </span><span class="n" id="mwCnc">NumberFormatException</span><span class="p" id="mwCng">)</span><span class="w" id="mwCnk"> </span><span class="p" id="mwCno">{</span> <span class="w" id="mwCns"> </span><span class="o" id="mwCnw">-</span><span class="m" id="mwCn0">1</span><span class="w" id="mwCn4"> </span><span class="c1" id="mwCn8">// result gets -1</span> <span class="p" id="mwCoA">}</span>Lisp
Common Lisp
<span id="mwCok"></span><span class="p" id="mwCoo">(</span><span class="nb" id="mwCos">ignore-errors</span><span class="w" id="mwCow"> </span><span class="p" id="mwCo0">(</span><span class="nb" id="mwCo4">/</span><span class="w" id="mwCo8"> </span><span class="mi" id="mwCpA">1</span><span class="w" id="mwCpE"> </span><span class="mi" id="mwCpI">0</span><span class="p" id="mwCpM">))</span> <span class="p" id="mwCpQ">(</span><span class="nb" id="mwCpU">handler-case</span> <span class="w" id="mwCpY"> </span><span class="p" id="mwCpc">(</span><span class="k" id="mwCpg">progn</span> <span class="w" id="mwCpk"> </span><span class="p" id="mwCpo">(</span><span class="nb" id="mwCps">print</span><span class="w" id="mwCpw"> </span><span class="s" id="mwCp0">"enter an expression"</span><span class="p" id="mwCp4">)</span> <span class="w" id="mwCp8"> </span><span class="p" id="mwCqA">(</span><span class="nb" id="mwCqE">eval</span><span class="w" id="mwCqI"> </span><span class="p" id="mwCqM">(</span><span class="nb" id="mwCqQ">read</span><span class="p" id="mwCqU">)))</span> <span class="w" id="mwCqY"> </span><span class="p" id="mwCqc">(</span><span class="nb" id="mwCqg">error</span><span class="w" id="mwCqk"> </span><span class="p" id="mwCqo">(</span><span class="nv" id="mwCqs">e</span><span class="p" id="mwCqw">)</span><span class="w" id="mwCq0"> </span><span class="p" id="mwCq4">(</span><span class="nb" id="mwCq8">print</span><span class="w" id="mwCrA"> </span><span class="nv" id="mwCrE">e</span><span class="p" id="mwCrI">)))</span> <span class="p" id="mwCrM">(</span><span class="k" id="mwCrQ">unwind-protect</span> <span class="w" id="mwCrU"> </span><span class="p" id="mwCrY">(</span><span class="k" id="mwCrc">progn</span> <span class="w" id="mwCrg"> </span><span class="p" id="mwCrk">(</span><span class="nb" id="mwCro">print</span><span class="w" id="mwCrs"> </span><span class="s" id="mwCrw">"enter an expression"</span><span class="p" id="mwCr0">)</span> <span class="w" id="mwCr4"> </span><span class="p" id="mwCr8">(</span><span class="nb" id="mwCsA">eval</span><span class="w" id="mwCsE"> </span><span class="p" id="mwCsI">(</span><span class="nb" id="mwCsM">read</span><span class="p" id="mwCsQ">)))</span> <span class="w" id="mwCsU"> </span><span class="p" id="mwCsY">(</span><span class="nb" id="mwCsc">print</span><span class="w" id="mwCsg"> </span><span class="s" id="mwCsk">"This print will always be executed, similar to finally."</span><span class="p" id="mwCso">))</span>
Lua
Lua uses the pcall and xpcall functions, with xpcall taking a function to act as a catch block.
- Predefined function
<span id="mwCtc"></span><span class="kr" id="mwCtg">function</span><span class="w" id="mwCtk"> </span><span class="nf" id="mwCto">foo</span><span class="p" id="mwCts">(</span><span class="nv" id="mwCtw">x</span><span class="p" id="mwCt0">)</span> <span class="w" id="mwCt4"> </span><span class="kr" id="mwCt8">if</span><span class="w" id="mwCuA"> </span><span class="nv" id="mwCuE">x</span><span class="w" id="mwCuI"> </span><span class="kr" id="mwCuM">then</span><span class="w" id="mwCuQ"> </span> <span class="w" id="mwCuU"> </span><span class="kr" id="mwCuY">return</span><span class="w" id="mwCuc"> </span><span class="nv" id="mwCug">x</span> <span class="w" id="mwCuk"> </span><span class="kr" id="mwCuo">else</span> <span class="w" id="mwCus"> </span><span class="nb" id="mwCuw">error</span><span class="w" id="mwCu0"> </span><span class="s2" id="mwCu4">"Not a true value"</span> <span class="w" id="mwCu8"> </span><span class="kr" id="mwCvA">end</span> <span class="kr" id="mwCvE">end</span> <span class="kr" id="mwCvI">function</span><span class="w" id="mwCvM"> </span><span class="nf" id="mwCvQ">attempt</span><span class="p" id="mwCvU">(</span><span class="nv" id="mwCvY">arg</span><span class="p" id="mwCvc">)</span> <span class="w" id="mwCvg"> </span><span class="nv" id="mwCvk">success</span><span class="p" id="mwCvo">,</span><span class="w" id="mwCvs"> </span><span class="nv" id="mwCvw">value</span><span class="w" id="mwCv0"> </span><span class="o" id="mwCv4">=</span><span class="w" id="mwCv8"> </span><span class="nb" id="mwCwA">pcall</span><span class="p" id="mwCwE">(</span><span class="nv" id="mwCwI">foo</span><span class="p" id="mwCwM">,</span><span class="w" id="mwCwQ"> </span><span class="nv" id="mwCwU">arg</span><span class="p" id="mwCwY">)</span> <span class="w" id="mwCwc"> </span><span class="kr" id="mwCwg">if</span><span class="w" id="mwCwk"> </span><span class="ow" id="mwCwo">not</span><span class="w" id="mwCws"> </span><span class="nv" id="mwCww">success</span><span class="w" id="mwCw0"> </span><span class="kr" id="mwCw4">then</span><span class="w" id="mwCw8"> </span> <span class="w" id="mwCxA"> </span><span class="nb" id="mwCxE">print</span><span class="p" id="mwCxI">(</span><span class="s2" id="mwCxM">"Error: "</span><span class="w" id="mwCxQ"> </span><span class="o" id="mwCxU">..</span><span class="w" id="mwCxY"> </span><span class="nb" id="mwCxc">tostring</span><span class="p" id="mwCxg">(</span><span class="nv" id="mwCxk">value</span><span class="p" id="mwCxo">))</span> <span class="w" id="mwCxs"> </span><span class="kr" id="mwCxw">else</span> <span class="w" id="mwCx0"> </span><span class="nb" id="mwCx4">print</span><span class="p" id="mwCx8">(</span><span class="s2" id="mwCyA">"Returned: "</span><span class="w" id="mwCyE"> </span><span class="o" id="mwCyI">..</span><span class="w" id="mwCyM"> </span><span class="nb" id="mwCyQ">tostring</span><span class="p" id="mwCyU">(</span><span class="nv" id="mwCyY">value</span><span class="p" id="mwCyc">))</span> <span class="w" id="mwCyg"> </span><span class="kr" id="mwCyk">end</span> <span class="kr" id="mwCyo">end</span> <span class="nf" id="mwCys">attempt</span><span class="p" id="mwCyw">(</span><span class="s2" id="mwCy0">"hello"</span><span class="p" id="mwCy4">)</span> <span class="w" id="mwCy8"> </span><span class="c1" id="mwCzA">-- Returned: hello</span> <span class="nf" id="mwCzE">attempt</span><span class="p" id="mwCzI">(</span><span class="kc" id="mwCzM">nil</span><span class="p" id="mwCzQ">)</span> <span class="w" id="mwCzU"> </span><span class="c1" id="mwCzY">-- Error: stdin:5: Not a true value</span> <span class="nf" id="mwCzc">attempt</span><span class="p" id="mwCzg">({})</span> <span class="w" id="mwCzk"> </span><span class="c1" id="mwCzo">-- Returned: table: 00809308</span> <span class="w" id="mwCzs"> </span> <span class="kr" id="mwCzw">if</span><span class="w" id="mwCz0"> </span><span class="nf" id="mwCz4">foo</span><span class="p" id="mwCz8">(</span><span class="mi" id="mwC0A">42</span><span class="p" id="mwC0E">)</span><span class="w" id="mwC0I"> </span><span class="kr" id="mwC0M">then</span><span class="w" id="mwC0Q"> </span><span class="nb" id="mwC0U">print</span><span class="w" id="mwC0Y"> </span><span class="s2" id="mwC0c">"Success"</span><span class="w" id="mwC0g"> </span><span class="kr" id="mwC0k">end</span> <span class="w" id="mwC0o"> </span><span class="c1" id="mwC0s">-- Success</span>- Anonymous function
<span id="mwC1A"></span><span class="kr" id="mwC1E">if</span><span class="w" id="mwC1I"> </span><span class="nb" id="mwC1M">pcall</span><span class="p" id="mwC1Q">(</span> <span class="w" id="mwC1U"> </span><span class="kr" id="mwC1Y">function</span><span class="p" id="mwC1c">()</span> <span class="w" id="mwC1g"> </span><span class="c1" id="mwC1k">-- Do something that might throw an error.</span> <span class="w" id="mwC1o"> </span><span class="kr" id="mwC1s">end</span><span class="p" id="mwC1w">)</span><span class="w" id="mwC10"> </span> <span class="kr" id="mwC14">then</span> <span class="w" id="mwC18"> </span><span class="nb" id="mwC2A">print</span><span class="w" id="mwC2E"> </span><span class="s2" id="mwC2I">"No errors"</span><span class="w" id="mwC2M"> </span><span class="c1" id="mwC2Q">-- Executed if the protected call was successful.</span> <span class="kr" id="mwC2U">else</span> <span class="w" id="mwC2Y"> </span><span class="nb" id="mwC2c">print</span><span class="w" id="mwC2g"> </span><span class="s2" id="mwC2k">"Error encountered"</span><span class="w" id="mwC2o"> </span><span class="c1" id="mwC2s">-- Executed if the protected call failed.</span> <span class="kr" id="mwC2w">end</span> <span class="nb" id="mwC20">print</span><span class="w" id="mwC24"> </span><span class="s2" id="mwC28">"Done"</span><span class="w" id="mwC3A"> </span><span class="c1" id="mwC3E">-- Will always be executed</span>
Next Generation Shell
- Defining custom exception type
<span id="mwC3c"></span><span class="nb" id="mwC3g">type </span><span class="n" id="mwC3k">MyError</span><span class="p" id="mwC3o">(</span><span class="n" id="mwC3s">Error</span><span class="p" id="mwC3w">)</span>
- Raising exceptions
<span id="mwC4E"></span><span class="k" id="mwC4I">throw</span> <span class="n" id="mwC4M">MyError</span><span class="p" id="mwC4Q">(</span><span class="s2" id="mwC4U">"this happened"</span><span class="p" id="mwC4Y">)</span>
- Exception handling and propagation
<span id="mwC4s"></span><span class="k" id="mwC4w">try</span> <span class="p" id="mwC40">{</span> <span class="c" id="mwC44"># something</span> <span class="p" id="mwC48">}</span> <span class="k" id="mwC5A">catch</span><span class="p" id="mwC5E">(</span><span class="n" id="mwC5I">e</span><span class="p" id="mwC5M">:</span><span class="n" id="mwC5Q">MyError</span><span class="p" id="mwC5U">)</span> <span class="p" id="mwC5Y">{</span> <span class="n" id="mwC5c">guard</span> <span class="n" id="mwC5g">e</span><span class="p" id="mwC5k">.</span><span class="n" id="mwC5o">val</span> <span class="p" id="mwC5s">=</span> <span class="n" id="mwC5w">7</span> <span class="c" id="mwC50"># ...</span> <span class="p" id="mwC54">}</span> <span class="k" id="mwC58">catch</span><span class="p" id="mwC6A">(</span><span class="n" id="mwC6E">e</span><span class="p" id="mwC6I">:</span><span class="n" id="mwC6M">MyError</span><span class="p" id="mwC6Q">)</span> <span class="p" id="mwC6U">{</span> <span class="c" id="mwC6Y"># ...</span> <span class="p" id="mwC6c">}</span> <span class="k" id="mwC6g">catch</span><span class="p" id="mwC6k">(</span><span class="n" id="mwC6o">e</span><span class="p" id="mwC6s">:</span><span class="n" id="mwC6w">Error</span><span class="p" id="mwC60">)</span> <span class="p" id="mwC64">{</span> <span class="c" id="mwC68"># ...</span> <span class="p" id="mwC7A">}</span>- Ignoring exceptions - try without catch
<span id="mwC7U"></span><span class="k" id="mwC7Y">try</span> <span class="n" id="mwC7c">1</span><span class="p" id="mwC7g">/</span><span class="n" id="mwC7k">0</span> <span class="c" id="mwC7o"># evaluates to null</span>
- Ignoring exceptions - "tor" operator
"tor" is try-or operator. In case of any exception when evaluating the argument on the left, evaluates to the argument on the right.
<span id="mwC8A"></span><span class="n" id="mwC8E">1</span><span class="p" id="mwC8I">/</span><span class="n" id="mwC8M">0</span> <span class="n" id="mwC8Q">tor</span> <span class="n" id="mwC8U">20</span> <span class="c" id="mwC8Y"># evaluates to 20</span>
- "block" - facility to use exceptions to return a value
<span id="mwC8s"></span><span class="n" id="mwC8w">my_result</span> <span class="p" id="mwC80">=</span> <span class="n" id="mwC84">block</span> <span class="n" id="mwC88">my_block</span> <span class="p" id="mwC9A">{</span> <span class="c" id="mwC9E"># "block" catches exception thrown by return below</span> <span class="c" id="mwC9I"># do calculation</span> <span class="k" id="mwC9M">if</span> <span class="n" id="mwC9Q">calculation_finished</span><span class="p" id="mwC9U">()</span> <span class="p" id="mwC9Y">{</span> <span class="n" id="mwC9c">my_block</span><span class="p" id="mwC9g">.</span><span class="k" id="mwC9k">return</span><span class="p" id="mwC9o">(</span><span class="n" id="mwC9s">42</span><span class="p" id="mwC9w">)</span> <span class="c" id="mwC90"># throws exception</span> <span class="p" id="mwC94">}</span> <span class="p" id="mwC98">}</span>Objective-C
- Exception declarations
<span id="mwC-c"></span><span class="bp" id="mwC-g">NSException</span><span class="w" id="mwC-k"> </span><span class="o" id="mwC-o">*</span><span class="n" id="mwC-s">exception</span><span class="w" id="mwC-w"> </span><span class="o" id="mwC-0">=</span><span class="w" id="mwC-4"> </span><span class="p" id="mwC-8">[</span><span class="bp" id="mwC_A">NSException</span><span class="w" id="mwC_E"> </span><span class="n" id="mwC_I">exceptionWithName</span><span class="o" id="mwC_M">:</span><span class="s" id="mwC_Q">@"myException"</span> <span class="w" id="mwC_U"> </span><span class="nl" id="mwC_Y">reason</span><span class="p" id="mwC_c">:</span><span class="s" id="mwC_g">@"yourReason"</span><span class="w" id="mwC_k"> </span><span class="n" id="mwC_o">userInfo</span><span class="o" id="mwC_s">:</span><span class="nb" id="mwC_w">nil</span><span class="p" id="mwC_0">];</span>
- Raising exceptions
<span id="mwDAI"></span><span class="k" id="mwDAM">@throw</span><span class="w" id="mwDAQ"> </span><span class="n" id="mwDAU">exception</span><span class="p" id="mwDAY">;</span>
- Exception handling and propagation
<span id="mwDAs"></span><span class="k" id="mwDAw">@try</span><span class="w" id="mwDA0"> </span><span class="p" id="mwDA4">{</span> <span class="w" id="mwDA8"> </span><span class="p" id="mwDBA">...</span> <span class="p" id="mwDBE">}</span> <span class="k" id="mwDBI">@catch</span><span class="w" id="mwDBM"> </span><span class="p" id="mwDBQ">(</span><span class="n" id="mwDBU">SomeException</span><span class="w" id="mwDBY"> </span><span class="o" id="mwDBc">*</span><span class="n" id="mwDBg">se</span><span class="p" id="mwDBk">)</span><span class="w" id="mwDBo"> </span><span class="p" id="mwDBs">{</span> <span class="w" id="mwDBw"> </span><span class="c1" id="mwDB0">// Handle a specific exception type.</span> <span class="w" id="mwDB4"> </span><span class="p" id="mwDB8">...</span> <span class="p" id="mwDCA">}</span> <span class="k" id="mwDCE">@catch</span><span class="w" id="mwDCI"> </span><span class="p" id="mwDCM">(</span><span class="bp" id="mwDCQ">NSException</span><span class="w" id="mwDCU"> </span><span class="o" id="mwDCY">*</span><span class="n" id="mwDCc">ne</span><span class="p" id="mwDCg">)</span><span class="w" id="mwDCk"> </span><span class="p" id="mwDCo">{</span> <span class="w" id="mwDCs"> </span><span class="c1" id="mwDCw">// Handle general exceptions.</span> <span class="w" id="mwDC0"> </span><span class="p" id="mwDC4">...</span> <span class="w" id="mwDC8"> </span><span class="c1" id="mwDDA">// Propagate the exception so that it's handled at a higher level.</span> <span class="w" id="mwDDE"> </span><span class="k" id="mwDDI">@throw</span><span class="p" id="mwDDM">;</span> <span class="p" id="mwDDQ">}</span> <span class="k" id="mwDDU">@catch</span><span class="w" id="mwDDY"> </span><span class="p" id="mwDDc">(</span><span class="kt" id="mwDDg">id</span><span class="w" id="mwDDk"> </span><span class="n" id="mwDDo">ue</span><span class="p" id="mwDDs">)</span><span class="w" id="mwDDw"> </span><span class="p" id="mwDD0">{</span> <span class="w" id="mwDD4"> </span><span class="c1" id="mwDD8">// Catch all thrown objects.</span> <span class="w" id="mwDEA"> </span><span class="p" id="mwDEE">...</span> <span class="p" id="mwDEI">}</span> <span class="k" id="mwDEM">@finally</span><span class="w" id="mwDEQ"> </span><span class="p" id="mwDEU">{</span> <span class="w" id="mwDEY"> </span><span class="c1" id="mwDEc">// Perform cleanup, whether an exception occurred or not.</span> <span class="w" id="mwDEg"> </span><span class="p" id="mwDEk">...</span> <span class="p" id="mwDEo">}</span>OCaml
<span id="mwDFA"></span><span class="k" id="mwDFE">exception</span> <span class="nc" id="mwDFI">MyException</span> <span class="k" id="mwDFM">of</span> <span class="kt" id="mwDFQ">string</span> <span class="o" id="mwDFU">*</span> <span class="kt" id="mwDFY">int</span> <span class="c" id="mwDFc">(* exceptions can carry a value *)</span> <span class="k" id="mwDFg">let</span> <span class="o" id="mwDFk">_</span> <span class="o" id="mwDFo">=</span> <span class="k" id="mwDFs">try</span> <span class="k" id="mwDFw">raise</span> <span class="o" id="mwDF0">(</span><span class="nc" id="mwDF4">MyException</span> <span class="o" id="mwDF8">(</span><span class="s2" id="mwDGA">"not enough food"</span><span class="o" id="mwDGE">,</span> <span class="mi" id="mwDGI">2</span><span class="o" id="mwDGM">));</span> <span class="n" id="mwDGQ">print_endline</span> <span class="s2" id="mwDGU">"Not reached"</span> <span class="k" id="mwDGY">with</span> <span class="o" id="mwDGc">|</span> <span class="nc" id="mwDGg">MyException</span> <span class="o" id="mwDGk">(</span><span class="n" id="mwDGo">s</span><span class="o" id="mwDGs">,</span> <span class="n" id="mwDGw">i</span><span class="o" id="mwDG0">)</span> <span class="o" id="mwDG4">-></span> <span class="nn" id="mwDG8">Printf</span><span class="p" id="mwDHA">.</span><span class="n" id="mwDHE">printf</span> <span class="s2" id="mwDHI">"MyException: %s, %d</span><span class="se" id="mwDHM">\n</span><span class="s2" id="mwDHQ">"</span> <span class="n" id="mwDHU">s</span> <span class="n" id="mwDHY">i</span> <span class="o" id="mwDHc">|</span> <span class="n" id="mwDHg">e</span> <span class="o" id="mwDHk">-></span> <span class="c" id="mwDHo">(* catch all exceptions *)</span> <span class="nn" id="mwDHs">Printf</span><span class="p" id="mwDHw">.</span><span class="n" id="mwDH0">eprintf</span> <span class="s2" id="mwDH4">"Unexpected exception : %s"</span> <span class="o" id="mwDH8">(</span><span class="nn" id="mwDIA">Printexc</span><span class="p" id="mwDIE">.</span><span class="n" id="mwDII">to_string</span> <span class="n" id="mwDIM">e</span><span class="o" id="mwDIQ">);</span> <span class="c" id="mwDIU">(*If using Ocaml >= 3.11, it is possible to also print a backtrace: *)</span> <span class="nn" id="mwDIY">Printexc</span><span class="p" id="mwDIc">.</span><span class="n" id="mwDIg">print_backtrace</span> <span class="n" id="mwDIk">stderr</span><span class="o" id="mwDIo">;</span> <span class="c" id="mwDIs">(* Needs to beforehand enable backtrace recording with</span> <span class="c" id="mwDIw"> Printexc.record_backtrace true</span> <span class="c" id="mwDI0"> or by setting the environment variable OCAMLRUNPARAM="b1"*)</span>
Perl 5
The Perl mechanism for exception handling uses die to throw an exception when wrapped inside an eval { ... }; block. After the eval, the special variable $@ contains the value passed from die.
Perl 5.005 added the ability to throw objects as well as strings. This allows better introspection and handling of types of exceptions.
<span id="mwDKs"></span><span class="nb" id="mwDKw">eval</span><span class="w" id="mwDK0"> </span><span class="p" id="mwDK4">{</span> <span class="w" id="mwDK8"> </span><span class="nb" id="mwDLA">open</span><span class="p" id="mwDLE">(</span><span class="n" id="mwDLI">FILE</span><span class="p" id="mwDLM">,</span><span class="w" id="mwDLQ"> </span><span class="nv" id="mwDLU">$file</span><span class="p" id="mwDLY">)</span><span class="w" id="mwDLc"> </span><span class="o" id="mwDLg">||</span><span class="w" id="mwDLk"> </span><span class="nb" id="mwDLo">die</span><span class="w" id="mwDLs"> </span><span class="nn" id="mwDLw">MyException::File</span><span class="o" id="mwDL0">-></span><span class="k" id="mwDL4">new</span><span class="p" id="mwDL8">(</span><span class="vg" id="mwDMA">$!</span><span class="p" id="mwDME">);</span> <span class="w" id="mwDMI"> </span><span class="k" id="mwDMM">while</span><span class="w" id="mwDMQ"> </span><span class="p" id="mwDMU">(</span><span class="sr" id="mwDMY"><FILE></span><span class="p" id="mwDMc">)</span><span class="w" id="mwDMg"> </span><span class="p" id="mwDMk">{</span> <span class="w" id="mwDMo"> </span><span class="n" id="mwDMs">process_line</span><span class="p" id="mwDMw">(</span><span class="nv" id="mwDM0">$_</span><span class="p" id="mwDM4">);</span> <span class="w" id="mwDM8"> </span><span class="p" id="mwDNA">}</span> <span class="w" id="mwDNE"> </span><span class="nb" id="mwDNI">close</span><span class="p" id="mwDNM">(</span><span class="n" id="mwDNQ">FILE</span><span class="p" id="mwDNU">)</span><span class="w" id="mwDNY"> </span><span class="o" id="mwDNc">||</span><span class="w" id="mwDNg"> </span><span class="nb" id="mwDNk">die</span><span class="w" id="mwDNo"> </span><span class="nn" id="mwDNs">MyException::File</span><span class="o" id="mwDNw">-></span><span class="k" id="mwDN0">new</span><span class="p" id="mwDN4">(</span><span class="vg" id="mwDN8">$!</span><span class="p" id="mwDOA">);</span> <span class="p" id="mwDOE">};</span> <span class="k" id="mwDOI">if</span><span class="w" id="mwDOM"> </span><span class="p" id="mwDOQ">(</span><span class="vg" id="mwDOU">$@</span><span class="p" id="mwDOY">)</span><span class="w" id="mwDOc"> </span><span class="p" id="mwDOg">{</span> <span class="w" id="mwDOk"> </span><span class="c1" id="mwDOo"># The exception object is in $@</span> <span class="w" id="mwDOs"> </span><span class="k" id="mwDOw">if</span><span class="w" id="mwDO0"> </span><span class="p" id="mwDO4">(</span><span class="vg" id="mwDO8">$@</span><span class="o" id="mwDPA">-></span><span class="n" id="mwDPE">isa</span><span class="p" id="mwDPI">(</span><span class="s" id="mwDPM">'MyException::File'</span><span class="p" id="mwDPQ">))</span><span class="w" id="mwDPU"> </span><span class="p" id="mwDPY">{</span> <span class="w" id="mwDPc"> </span><span class="c1" id="mwDPg"># Handle file exception</span> <span class="w" id="mwDPk"> </span><span class="p" id="mwDPo">}</span><span class="w" id="mwDPs"> </span><span class="k" id="mwDPw">else</span><span class="w" id="mwDP0"> </span><span class="p" id="mwDP4">{</span> <span class="w" id="mwDP8"> </span><span class="c1" id="mwDQA"># Generic exception handling</span> <span class="w" id="mwDQE"> </span><span class="c1" id="mwDQI"># or re-throw with 'die $@'</span> <span class="w" id="mwDQM"> </span><span class="p" id="mwDQQ">}</span> <span class="p" id="mwDQU">}</span>The __DIE__ pseudo-signal can be trapped to handle calls to die. This is not suitable for exception handling since it is global. However it can be used to convert string-based exceptions from third-party packages into objects.
<span id="mwDQ8"></span><span class="nb" id="mwDRA">local</span><span class="w" id="mwDRE"> </span><span class="nv" id="mwDRI">$SIG</span><span class="p" id="mwDRM">{</span><span class="bp" id="mwDRQ">__DIE__</span><span class="p" id="mwDRU">}</span><span class="w" id="mwDRY"> </span><span class="o" id="mwDRc">=</span><span class="w" id="mwDRg"> </span><span class="k" id="mwDRk">sub</span><span class="w" id="mwDRo"> </span><span class="p" id="mwDRs">{</span> <span class="w" id="mwDRw"> </span><span class="k" id="mwDR0">my</span><span class="w" id="mwDR4"> </span><span class="nv" id="mwDR8">$err</span><span class="w" id="mwDSA"> </span><span class="o" id="mwDSE">=</span><span class="w" id="mwDSI"> </span><span class="nb" id="mwDSM">shift</span><span class="p" id="mwDSQ">;</span> <span class="w" id="mwDSU"> </span><span class="k" id="mwDSY">if</span><span class="w" id="mwDSc"> </span><span class="p" id="mwDSg">(</span><span class="nv" id="mwDSk">$err</span><span class="o" id="mwDSo">-></span><span class="n" id="mwDSs">isa</span><span class="p" id="mwDSw">(</span><span class="s" id="mwDS0">'MyException'</span><span class="p" id="mwDS4">))</span><span class="w" id="mwDS8"> </span><span class="p" id="mwDTA">{</span> <span class="w" id="mwDTE"> </span><span class="nb" id="mwDTI">die</span><span class="w" id="mwDTM"> </span><span class="nv" id="mwDTQ">$err</span><span class="p" id="mwDTU">;</span><span class="w" id="mwDTY"> </span><span class="c1" id="mwDTc"># re-throw</span> <span class="w" id="mwDTg"> </span><span class="p" id="mwDTk">}</span><span class="w" id="mwDTo"> </span><span class="k" id="mwDTs">else</span><span class="w" id="mwDTw"> </span><span class="p" id="mwDT0">{</span> <span class="w" id="mwDT4"> </span><span class="c1" id="mwDT8"># Otherwise construct a MyException with $err as a string</span> <span class="w" id="mwDUA"> </span><span class="nb" id="mwDUE">die</span><span class="w" id="mwDUI"> </span><span class="nn" id="mwDUM">MyException::Default</span><span class="o" id="mwDUQ">-></span><span class="k" id="mwDUU">new</span><span class="p" id="mwDUY">(</span><span class="nv" id="mwDUc">$err</span><span class="p" id="mwDUg">);</span> <span class="w" id="mwDUk"> </span><span class="p" id="mwDUo">}</span> <span class="p" id="mwDUs">};</span>The forms shown above can sometimes fail if the global variable $@ is changed between when the exception is thrown and when it is checked in the if ($@) statement. This can happen in multi-threaded environments, or even in single-threaded environments when other code (typically called in the destruction of some object) resets the global variable before the checking code. The following example shows a way to avoid this problem (see [link removed] or ; cf. ). But at the cost of not being able to use return values:
<span id="mwDV8"></span><span class="nb" id="mwDWA">eval</span><span class="w" id="mwDWE"> </span><span class="p" id="mwDWI">{</span> <span class="w" id="mwDWM"> </span><span class="c1" id="mwDWQ"># Code that could throw an exception (using 'die') but does NOT use the return statement;</span> <span class="w" id="mwDWU"> </span><span class="mi" id="mwDWY">1</span><span class="p" id="mwDWc">;</span> <span class="p" id="mwDWg">}</span><span class="w" id="mwDWk"> </span><span class="ow" id="mwDWo">or</span><span class="w" id="mwDWs"> </span><span class="k" id="mwDWw">do</span><span class="w" id="mwDW0"> </span><span class="p" id="mwDW4">{</span> <span class="w" id="mwDW8"> </span><span class="c1" id="mwDXA"># Handle exception here. The exception string is in $@</span> <span class="p" id="mwDXE">};</span>Several modules in the Comprehensive Perl Archive Network (CPAN) expand on the basic mechanism:
Errorprovides a set of exception classes and allows use of the try/throw/catch/finally syntax.TryCatch,Try::TinyandNice::Tryall allow the use of try/catch/finally syntax instead of boilerplate to handle exceptions correctly.Exception::Classis a base class and class-maker for derived exception classes. It provides a full structured stack trace in$@->traceand$@->trace->as_string.Fataloverloads previously defined functions that return true/false e.g.,open,close,read,write, etc. This allows built-in functions and others to be used as if they threw exceptions.
PHP
<span id="mwDaw"></span><span class="c1" id="mwDa0">// Exception handling is only available in PHP versions 5 and greater.</span> <span class="k" id="mwDa4">try</span> <span class="p" id="mwDa8">{</span> <span class="c1" id="mwDbA">// Code that might throw an exception</span> <span class="k" id="mwDbE">throw</span> <span class="k" id="mwDbI">new</span> <span class="nx" id="mwDbM">Exception</span><span class="p" id="mwDbQ">(</span><span class="s1" id="mwDbU">'Invalid URL.'</span><span class="p" id="mwDbY">);</span> <span class="p" id="mwDbc">}</span> <span class="k" id="mwDbg">catch</span> <span class="p" id="mwDbk">(</span><span class="nx" id="mwDbo">FirstExceptionClass</span> <span class="nv" id="mwDbs">$exception</span><span class="p" id="mwDbw">)</span> <span class="p" id="mwDb0">{</span> <span class="c1" id="mwDb4">// Code that handles this exception</span> <span class="p" id="mwDb8">}</span> <span class="k" id="mwDcA">catch</span> <span class="p" id="mwDcE">(</span><span class="nx" id="mwDcI">SecondExceptionClass</span> <span class="nv" id="mwDcM">$exception</span><span class="p" id="mwDcQ">)</span> <span class="p" id="mwDcU">{</span> <span class="c1" id="mwDcY">// Code that handles a different exception</span> <span class="p" id="mwDcc">}</span> <span class="k" id="mwDcg">finally</span> <span class="p" id="mwDck">{</span> <span class="c1" id="mwDco">// Perform cleanup, whether an exception occurred or not.</span> <span class="p" id="mwDcs">}</span>PowerBuilder
Exception handling is available in PowerBuilder versions 8.0 and above.
TRY // Normal execution path CATCH (ExampleException ee) // deal with the ExampleException FINALLY // This optional section is executed upon termination of any of the try or catch blocks above END TRY
PowerShell
Version 1.0
<span id="mwDdg"></span><span class="k" id="mwDdk">trap</span> <span class="no" id="mwDdo">[Exception]</span> <span class="p" id="mwDds">{</span> <span class="c" id="mwDdw"># Statements that execute in the event of an exception</span> <span class="p" id="mwDd0">}</span> <span class="c" id="mwDd4"># Statements in which exceptions might be thrown</span>Version 2.0
<span id="mwDeI"></span><span class="k" id="mwDeM">Try</span> <span class="p" id="mwDeQ">{</span> <span class="nb" id="mwDeU">Import-Module</span> <span class="n" id="mwDeY">ActiveDirectory</span> <span class="p" id="mwDec">}</span> <span class="k" id="mwDeg">Catch</span> <span class="no" id="mwDek">[Exception1]</span> <span class="p" id="mwDeo">{</span> <span class="c" id="mwDes"># Statements that execute in the event of an exception, matching the exception</span> <span class="p" id="mwDew">}</span> <span class="k" id="mwDe0">Catch</span> <span class="no" id="mwDe4">[Exception2],[Exception3etc]</span> <span class="p" id="mwDe8">{</span> <span class="c" id="mwDfA"># Statements that execute in the event of an exception, matching any of the exceptions</span> <span class="p" id="mwDfE">}</span> <span class="k" id="mwDfI">Catch</span> <span class="p" id="mwDfM">{</span> <span class="c" id="mwDfQ"># Statements that execute in the event of an exception, not handled more specifically</span> <span class="p" id="mwDfU">}</span>Python
<span id="mwDfs"></span><span class="kn" id="mwDfw">from</span><span class="w" id="mwDf0"> </span><span class="nn" id="mwDf4">io</span><span class="w" id="mwDf8"> </span><span class="kn" id="mwDgA">import</span> <span class="n" id="mwDgE">TextIOWrapper</span> <span class="n" id="mwDgI">f</span><span class="p" id="mwDgM">:</span> <span class="n" id="mwDgQ">TextIOWrapper</span> <span class="o" id="mwDgU">|</span> <span class="kc" id="mwDgY">None</span> <span class="o" id="mwDgc">=</span> <span class="kc" id="mwDgg">None</span> <span class="k" id="mwDgk">try</span><span class="p" id="mwDgo">:</span> <span class="n" id="mwDgs">f</span> <span class="o" id="mwDgw">=</span> <span class="nb" id="mwDg0">open</span><span class="p" id="mwDg4">(</span><span class="s2" id="mwDg8">"aFileName"</span><span class="p" id="mwDhA">,</span> <span class="s2" id="mwDhE">"w"</span><span class="p" id="mwDhI">)</span> <span class="n" id="mwDhM">f</span><span class="o" id="mwDhQ">.</span><span class="n" id="mwDhU">write</span><span class="p" id="mwDhY">(</span><span class="n" id="mwDhc">could_make_error</span><span class="p" id="mwDhg">())</span> <span class="k" id="mwDhk">except</span> <span class="ne" id="mwDho">IOError</span><span class="p" id="mwDhs">:</span> <span class="nb" id="mwDhw">print</span><span class="p" id="mwDh0">(</span><span class="s2" id="mwDh4">"Unable to open file"</span><span class="p" id="mwDh8">)</span> <span class="k" id="mwDiA">except</span><span class="p" id="mwDiE">:</span> <span class="c1" id="mwDiI"># catch all exceptions</span> <span class="nb" id="mwDiM">print</span><span class="p" id="mwDiQ">(</span><span class="s2" id="mwDiU">"Unexpected error"</span><span class="p" id="mwDiY">)</span> <span class="k" id="mwDic">else</span><span class="p" id="mwDig">:</span> <span class="c1" id="mwDik"># executed if no exceptions are raised</span> <span class="nb" id="mwDio">print</span><span class="p" id="mwDis">(</span><span class="s2" id="mwDiw">"File write completed successfully"</span><span class="p" id="mwDi0">)</span> <span class="k" id="mwDi4">finally</span><span class="p" id="mwDi8">:</span> <span class="c1" id="mwDjA"># clean-up actions, always executed</span> <span class="k" id="mwDjE">if</span> <span class="n" id="mwDjI">f</span><span class="p" id="mwDjM">:</span> <span class="n" id="mwDjQ">f</span><span class="o" id="mwDjU">.</span><span class="n" id="mwDjY">close</span><span class="p" id="mwDjc">()</span>
R
<span id="mwDj0"></span><span class="nf" id="mwDj4">tryCatch</span><span class="p" id="mwDj8">({</span> <span class="w" id="mwDkA"> </span><span class="nf" id="mwDkE">stop</span><span class="p" id="mwDkI">(</span><span class="s" id="mwDkM">"Here an error is signaled"</span><span class="p" id="mwDkQ">)</span><span class="w" id="mwDkU"> </span><span class="c1" id="mwDkY"># default S3-class is simpleError a subclass of error</span> <span class="w" id="mwDkc"> </span><span class="nf" id="mwDkg">cat</span><span class="p" id="mwDkk">(</span><span class="s" id="mwDko">"This and the following lines are not executed because the error is trapped before\n"</span><span class="p" id="mwDks">)</span> <span class="w" id="mwDkw"> </span><span class="nf" id="mwDk0">stop</span><span class="p" id="mwDk4">(</span><span class="w" id="mwDk8"> </span><span class="nf" id="mwDlA">structure</span><span class="p" id="mwDlE">(</span><span class="nf" id="mwDlI">simpleError</span><span class="p" id="mwDlM">(</span><span class="s" id="mwDlQ">"mySpecialError message"</span><span class="p" id="mwDlU">),</span><span class="n" id="mwDlY">class</span><span class="o" id="mwDlc">=</span><span class="nf" id="mwDlg">c</span><span class="p" id="mwDlk">(</span><span class="s" id="mwDlo">"specialError"</span><span class="p" id="mwDls">,</span><span class="s" id="mwDlw">"error"</span><span class="p" id="mwDl0">,</span><span class="s" id="mwDl4">"condition"</span><span class="p" id="mwDl8">))</span><span class="w" id="mwDmA"> </span><span class="p" id="mwDmE">)</span> <span class="p" id="mwDmI">}</span> <span class="p" id="mwDmM">,</span><span class="n" id="mwDmQ">specialError</span><span class="o" id="mwDmU">=</span><span class="kr" id="mwDmY">function</span><span class="p" id="mwDmc">(</span><span class="n" id="mwDmg">e</span><span class="p" id="mwDmk">){</span> <span class="w" id="mwDmo"> </span><span class="nf" id="mwDms">cat</span><span class="p" id="mwDmw">(</span><span class="s" id="mwDm0">"catches errors of class specialError\n"</span><span class="p" id="mwDm4">)</span> <span class="p" id="mwDm8">}</span> <span class="p" id="mwDnA">,</span><span class="n" id="mwDnE">error</span><span class="o" id="mwDnI">=</span><span class="kr" id="mwDnM">function</span><span class="p" id="mwDnQ">(</span><span class="n" id="mwDnU">e</span><span class="p" id="mwDnY">){</span> <span class="w" id="mwDnc"> </span><span class="nf" id="mwDng">cat</span><span class="p" id="mwDnk">(</span><span class="s" id="mwDno">"catches the default error\n"</span><span class="p" id="mwDns">)</span> <span class="p" id="mwDnw">}</span> <span class="p" id="mwDn0">,</span><span class="n" id="mwDn4">finally</span><span class="o" id="mwDn8">=</span><span class="p" id="mwDoA">{</span><span class="w" id="mwDoE"> </span><span class="nf" id="mwDoI">cat</span><span class="p" id="mwDoM">(</span><span class="s" id="mwDoQ">"do some cleanup (e.g., setwd)\n"</span><span class="p" id="mwDoU">)</span><span class="w" id="mwDoY"> </span><span class="p" id="mwDoc">}</span> <span class="p" id="mwDog">)</span>Rebol
<span id="mwDo4"></span><span class="gh" id="mwDo8">REBOL</span> <span class="gs" id="mwDpA">[</span> <span class="gu" id="mwDpE">Title:</span> <span class="s" id="mwDpI">"Exception and error handling examples"</span> <span class="gs" id="mwDpM">]</span> <span class="c" id="mwDpQ">; TRY a block; capturing an error! and converting to object!</span> <span class="nb" id="mwDpU">if</span> <span class="k" id="mwDpY">error?</span> <span class="gu" id="mwDpc">exception:</span> <span class="nb" id="mwDpg">try</span> <span class="gs" id="mwDpk">[</span><span class="m" id="mwDpo">1</span> <span class="na" id="mwDps">/</span> <span class="m" id="mwDpw">0</span><span class="gs" id="mwDp0">][</span><span class="kn" id="mwDp4">probe</span> <span class="nb" id="mwDp8">disarm</span> <span class="nv" id="mwDqA">exception</span><span class="gs" id="mwDqE">]</span> <span class="c" id="mwDqI">; ATTEMPT results in the value of the block or the value none on error</span> <span class="nb" id="mwDqM">print</span> <span class="kn" id="mwDqQ">attempt</span> <span class="gs" id="mwDqU">[</span><span class="nf" id="mwDqY">divide</span> <span class="m" id="mwDqc">1</span> <span class="m" id="mwDqg">0</span><span class="gs" id="mwDqk">]</span> <span class="c" id="mwDqo">; User generated exceptions can be any datatype!</span> <span class="gu" id="mwDqs">example:</span> <span class="kn" id="mwDqw">func</span> <span class="gs" id="mwDq0">[</span><span class="s" id="mwDq4">"A function to throw an exception"</span> <span class="gs" id="mwDq8">][</span> <span class="nb" id="mwDrA">throw</span> <span class="s" id="mwDrE">"I'm a string! exception"</span> <span class="gs" id="mwDrI">]</span> <span class="nb" id="mwDrM">catch</span> <span class="gs" id="mwDrQ">[</span><span class="nv" id="mwDrU">example</span><span class="gs" id="mwDrY">]</span> <span class="c" id="mwDrc">; User generated exceptions can also be named,</span> <span class="c" id="mwDrg">; and functions can include additional run time attributes </span> <span class="gu" id="mwDrk">sophisticated:</span> <span class="kn" id="mwDro">func</span> <span class="gs" id="mwDrs">[</span><span class="s" id="mwDrw">"A function to throw a named error exception"</span> <span class="gs" id="mwDr0">[</span><span class="nb" id="mwDr4">catch</span><span class="gs" id="mwDr8">]</span> <span class="gs" id="mwDsA">][</span> <span class="nb" id="mwDsE">throw</span><span class="na" id="mwDsI">/name</span> <span class="nf" id="mwDsM">make</span> <span class="kt" id="mwDsQ">error!</span> <span class="s" id="mwDsU">"I'm an error! exception"</span> <span class="vi" id="mwDsY">'moniker</span> <span class="gs" id="mwDsc">]</span> <span class="nb" id="mwDsg">catch</span><span class="na" id="mwDsk">/name</span> <span class="gs" id="mwDso">[</span><span class="nv" id="mwDss">sophisticated</span><span class="gs" id="mwDsw">]</span> <span class="vi" id="mwDs0">'moniker</span>
Rexx
<span id="mwDtM"></span><span class="w" id="mwDtQ"> </span><span class="kr" id="mwDtU">signal</span><span class="w" id="mwDtY"> </span><span class="kr" id="mwDtc">on</span><span class="w" id="mwDtg"> </span>halt<span class="err" id="mwDtk">;</span> <span class="w" id="mwDto"> </span><span class="kr" id="mwDts">do</span><span class="w" id="mwDtw"> </span>a<span class="w" id="mwDt0"> </span><span class="o" id="mwDt4">=</span><span class="w" id="mwDt8"> </span><span class="m" id="mwDuA">1</span> <span class="w" id="mwDuE"> </span><span class="kr" id="mwDuI">say</span><span class="w" id="mwDuM"> </span>a <span class="w" id="mwDuQ"> </span><span class="kr" id="mwDuU">do</span><span class="w" id="mwDuY"> </span><span class="m" id="mwDuc">100000</span><span class="w" id="mwDug"> </span><span class="cm" id="mwDuk">/* a delay */</span> <span class="w" id="mwDuo"> </span><span class="kr" id="mwDus">end</span> <span class="w" id="mwDuw"> </span><span class="kr" id="mwDu0">end</span> <span class="w" id="mwDu4"> </span><span class="nl" id="mwDu8">halt</span><span class="o" id="mwDvA">:</span> <span class="w" id="mwDvE"> </span><span class="kr" id="mwDvI">say</span><span class="w" id="mwDvM"> </span><span class="s" id="mwDvQ">"The program was stopped by the user"</span> <span class="w" id="mwDvU"> </span><span class="kr" id="mwDvY">exit</span>
Ruby
<span id="mwDvw"></span><span class="k" id="mwDv0">begin</span> <span class="w" id="mwDv4"> </span><span class="c1" id="mwDv8"># Do something nifty</span> <span class="w" id="mwDwA"> </span><span class="k" id="mwDwE">raise</span><span class="w" id="mwDwI"> </span><span class="no" id="mwDwM">SomeError</span><span class="p" id="mwDwQ">,</span><span class="w" id="mwDwU"> </span><span class="s2" id="mwDwY">"This is the error message!"</span><span class="w" id="mwDwc"> </span><span class="c1" id="mwDwg"># Uh-oh!</span> <span class="k" id="mwDwk">rescue</span><span class="w" id="mwDwo"> </span><span class="no" id="mwDws">SomeError</span> <span class="w" id="mwDww"> </span><span class="c1" id="mwDw0"># This is executed when a SomeError exception</span> <span class="w" id="mwDw4"> </span><span class="c1" id="mwDw8"># is raised</span> <span class="k" id="mwDxA">rescue</span><span class="w" id="mwDxE"> </span><span class="no" id="mwDxI">AnotherError</span><span class="w" id="mwDxM"> </span><span class="o" id="mwDxQ">=></span><span class="w" id="mwDxU"> </span><span class="n" id="mwDxY">error</span> <span class="w" id="mwDxc"> </span><span class="c1" id="mwDxg"># Here, the exception object is referenced from the</span> <span class="w" id="mwDxk"> </span><span class="c1" id="mwDxo"># `error' variable</span> <span class="k" id="mwDxs">rescue</span> <span class="w" id="mwDxw"> </span><span class="c1" id="mwDx0"># This catches all exceptions derived from StandardError</span> <span class="w" id="mwDx4"> </span><span class="k" id="mwDx8">retry</span><span class="w" id="mwDyA"> </span><span class="c1" id="mwDyE"># This executes the begin section again</span> <span class="k" id="mwDyI">else</span> <span class="w" id="mwDyM"> </span><span class="c1" id="mwDyQ"># This is executed only if no exceptions were raised</span> <span class="k" id="mwDyU">ensure</span> <span class="w" id="mwDyY"> </span><span class="c1" id="mwDyc"># This is always executed, exception or not</span> <span class="k" id="mwDyg">end</span>
Rust
Although Rust avoids the try/catch mechanism common in most exception handling languages, it still allows for catching panics, using the std::panic::catch_unwind() function, as the default behavior in Rust when a panic occurs is to perform stack unwinding.
<span id="mwDzg"></span><span class="k" id="mwDzk">use</span><span class="w" id="mwDzo"> </span><span class="n" id="mwDzs">std</span><span class="p" id="mwDzw">::</span><span class="n" id="mwDz0">panic</span><span class="p" id="mwDz4">;</span> <span class="k" id="mwDz8">use</span><span class="w" id="mwD0A"> </span><span class="n" id="mwD0E">std</span><span class="p" id="mwD0I">::</span><span class="n" id="mwD0M">thread</span><span class="p" id="mwD0Q">;</span> <span class="k" id="mwD0U">fn</span><span class="w" id="mwD0Y"> </span><span class="nf" id="mwD0c">main</span><span class="p" id="mwD0g">()</span><span class="w" id="mwD0k"> </span><span class="p" id="mwD0o">{</span> <span class="w" id="mwD0s"> </span><span class="kd" id="mwD0w">let</span><span class="w" id="mwD00"> </span><span class="n" id="mwD04">result</span><span class="p" id="mwD08">:</span><span class="w" id="mwD1A"> </span><span class="nc" id="mwD1E">thread</span><span class="p" id="mwD1I">::</span><span class="nb" id="mwD1M">Result</span><span class="o" id="mwD1Q"><</span><span class="p" id="mwD1U">()</span><span class="o" id="mwD1Y">></span><span class="w" id="mwD1c"> </span><span class="o" id="mwD1g">=</span><span class="w" id="mwD1k"> </span><span class="n" id="mwD1o">panic</span><span class="p" id="mwD1s">::</span><span class="n" id="mwD1w">catch_unwind</span><span class="p" id="mwD10">(</span><span class="o" id="mwD14">||</span><span class="w" id="mwD18"> </span><span class="p" id="mwD2A">{</span> <span class="w" id="mwD2E"> </span><span class="fm" id="mwD2I">println!</span><span class="p" id="mwD2M">(</span><span class="s" id="mwD2Q">"This runs normally."</span><span class="p" id="mwD2U">);</span> <span class="w" id="mwD2Y"> </span><span class="fm" id="mwD2c">panic!</span><span class="p" id="mwD2g">(</span><span class="s" id="mwD2k">"Something went wrong!"</span><span class="p" id="mwD2o">);</span><span class="w" id="mwD2s"> </span><span class="c1" id="mwD2w">// Trigger a panic</span> <span class="w" id="mwD20"> </span><span class="p" id="mwD24">});</span> <span class="w" id="mwD28"> </span><span class="k" id="mwD3A">if</span><span class="w" id="mwD3E"> </span><span class="n" id="mwD3I">result</span><span class="p" id="mwD3M">.</span><span class="n" id="mwD3Q">is_err</span><span class="p" id="mwD3U">()</span><span class="w" id="mwD3Y"> </span><span class="p" id="mwD3c">{</span> <span class="w" id="mwD3g"> </span><span class="fm" id="mwD3k">println!</span><span class="p" id="mwD3o">(</span><span class="s" id="mwD3s">"Caught the panic! The program will continue running."</span><span class="p" id="mwD3w">);</span> <span class="w" id="mwD30"> </span><span class="p" id="mwD34">}</span> <span class="p" id="mwD38">}</span>S-Lang
try { % code that might throw an exception } catch SomeError: { % code that handles this exception } catch SomeOtherError: { % code that handles this exception } finally % optional block { % This code will always get executed }New exceptions may be created using the new_exception function, e.g.,
new_exception ("MyIOError", IOError, "My I/O Error");will create an exception called MyIOError as a subclass of IOError. Exceptions may be generated using the throw statement, which can throw arbitrary S-Lang objects.
Smalltalk
<span id="mwD5A"></span> [ <span class="c" id="mwD5E">"code that might throw an exception"</span> ] <span class="nf" id="mwD5I">on:</span> <span class="nc" id="mwD5M">ExceptionClass</span> <span class="nf" id="mwD5Q">do:</span> [<span class="o" id="mwD5U">:</span><span class="nv" id="mwD5Y">ex</span> <span class="o" id="mwD5c">|</span> <span class="c" id="mwD5g">"code that handles exception"</span> ]<span class="p" id="mwD5k">.</span>
The general mechanism is provided by the message on:do:. Exceptions are just normal objects that subclass Error, you throw one by creating an instance and sending it a #signal message, e.g., MyException new signal. The handling mechanism (#on:do:) is again just a normal message implemented by BlockClosure. The thrown exception is passed as a parameter to the handling block closure, and can be queried, as well as potentially sending #resume to it, to allow execution flow to continue.
Swift
Exception handling is supported since Swift 2.
<span id="mwD74"></span><span class="kd" id="mwD78">enum</span><span class="w" id="mwD8A"> </span><span class="nc" id="mwD8E">MyException</span><span class="w" id="mwD8I"> </span><span class="p" id="mwD8M">:</span><span class="w" id="mwD8Q"> </span><span class="n" id="mwD8U">ErrorType</span><span class="w" id="mwD8Y"> </span><span class="p" id="mwD8c">{</span> <span class="w" id="mwD8g"> </span><span class="k" id="mwD8k">case</span><span class="w" id="mwD8o"> </span><span class="n" id="mwD8s">Foo</span><span class="p" id="mwD8w">(</span><span class="nb" id="mwD80">String</span><span class="p" id="mwD84">,</span><span class="w" id="mwD88"> </span><span class="nb" id="mwD9A">Int</span><span class="p" id="mwD9E">)</span> <span class="p" id="mwD9I">}</span> <span class="kd" id="mwD9M">func</span><span class="w" id="mwD9Q"> </span><span class="nf" id="mwD9U">someFunc</span><span class="p" id="mwD9Y">()</span><span class="w" id="mwD9c"> </span><span class="kr" id="mwD9g">throws</span><span class="w" id="mwD9k"> </span><span class="p" id="mwD9o">{</span> <span class="w" id="mwD9s"> </span><span class="k" id="mwD9w">throw</span><span class="w" id="mwD90"> </span><span class="n" id="mwD94">MyException</span><span class="p" id="mwD98">.</span><span class="n" id="mwD-A">Foo</span><span class="p" id="mwD-E">(</span><span class="s" id="mwD-I">"not enough food"</span><span class="p" id="mwD-M">,</span><span class="w" id="mwD-Q"> </span><span class="mi" id="mwD-U">2</span><span class="p" id="mwD-Y">)</span> <span class="p" id="mwD-c">}</span> <span class="k" id="mwD-g">do</span><span class="w" id="mwD-k"> </span><span class="p" id="mwD-o">{</span> <span class="w" id="mwD-s"> </span><span class="k" id="mwD-w">try</span><span class="w" id="mwD-0"> </span><span class="n" id="mwD-4">someFunc</span><span class="p" id="mwD-8">()</span> <span class="w" id="mwD_A"> </span><span class="bp" id="mwD_E">print</span><span class="p" id="mwD_I">(</span><span class="s" id="mwD_M">"Not reached"</span><span class="p" id="mwD_Q">)</span> <span class="p" id="mwD_U">}</span><span class="w" id="mwD_Y"> </span><span class="k" id="mwD_c">catch</span><span class="w" id="mwD_g"> </span><span class="n" id="mwD_k">MyException</span><span class="p" id="mwD_o">.</span><span class="n" id="mwD_s">Foo</span><span class="p" id="mwD_w">(</span><span class="kd" id="mwD_0">let</span><span class="w" id="mwD_4"> </span><span class="nv" id="mwD_8">s</span><span class="p" id="mwEAA">,</span><span class="w" id="mwEAE"> </span><span class="kd" id="mwEAI">let</span><span class="w" id="mwEAM"> </span><span class="nv" id="mwEAQ">i</span><span class="p" id="mwEAU">)</span><span class="w" id="mwEAY"> </span><span class="p" id="mwEAc">{</span> <span class="w" id="mwEAg"> </span><span class="bp" id="mwEAk">print</span><span class="p" id="mwEAo">(</span><span class="s" id="mwEAs">"MyException: </span><span class="si" id="mwEAw">\(</span><span class="n" id="mwEA0">s</span><span class="si" id="mwEA4">)</span><span class="s" id="mwEA8">, </span><span class="si" id="mwEBA">\(</span><span class="n" id="mwEBE">i</span><span class="si" id="mwEBI">)</span><span class="s" id="mwEBM">"</span><span class="p" id="mwEBQ">)</span> <span class="p" id="mwEBU">}</span><span class="w" id="mwEBY"> </span><span class="k" id="mwEBc">catch</span><span class="w" id="mwEBg"> </span><span class="p" id="mwEBk">{</span> <span class="w" id="mwEBo"> </span><span class="bp" id="mwEBs">print</span><span class="p" id="mwEBw">(</span><span class="s" id="mwEB0">"Unexpected exception : </span><span class="si" id="mwEB4">\(</span><span class="n" id="mwEB8">error</span><span class="si" id="mwECA">)</span><span class="s" id="mwECE">"</span><span class="p" id="mwECI">)</span> <span class="p" id="mwECM">}</span>Tcl
<span id="mwECk"></span><span class="k" id="mwECo">if</span><span class="w" id="mwECs"> </span><span class="k" id="mwECw">{</span><span class="w" id="mwEC0"> </span><span class="k" id="mwEC4">[</span><span class="w" id="mwEC8"> </span><span class="k" id="mwEDA">catch</span><span class="w" id="mwEDE"> </span><span class="k" id="mwEDI">{</span> <span class="w" id="mwEDM"> </span><span class="nv" id="mwEDQ">foo</span> <span class="k" id="mwEDU">}</span><span class="w" id="mwEDY"> </span>err<span class="w" id="mwEDc"> </span><span class="k" id="mwEDg">]</span><span class="w" id="mwEDk"> </span><span class="k" id="mwEDo">}</span><span class="w" id="mwEDs"> </span><span class="k" id="mwEDw">{</span> <span class="w" id="mwED0"> </span><span class="nb" id="mwED4">puts</span><span class="w" id="mwED8"> </span><span class="s2" id="mwEEA">"Error: $err"</span> <span class="k" id="mwEEE">}</span>Since Tcl 8.6, there is also a try command:
<span id="mwEEU"></span><span class="nv" id="mwEEY">try</span><span class="w" id="mwEEc"> </span><span class="k" id="mwEEg">{</span> <span class="w" id="mwEEk"> </span><span class="nv" id="mwEEo">someCommandWithExceptions</span> <span class="k" id="mwEEs">}</span><span class="w" id="mwEEw"> </span>on<span class="w" id="mwEE0"> </span>ok<span class="w" id="mwEE4"> </span><span class="k" id="mwEE8">{</span><span class="nv" id="mwEFA">res</span><span class="w" id="mwEFE"> </span>opt<span class="k" id="mwEFI">}</span><span class="w" id="mwEFM"> </span><span class="k" id="mwEFQ">{</span> <span class="w" id="mwEFU"> </span><span class="c" id="mwEFY"># handle normal case.</span> <span class="k" id="mwEFc">}</span><span class="w" id="mwEFg"> </span>trap<span class="w" id="mwEFk"> </span>ListPattern1<span class="w" id="mwEFo"> </span><span class="k" id="mwEFs">{</span><span class="nv" id="mwEFw">err</span><span class="w" id="mwEF0"> </span>opt<span class="k" id="mwEF4">}</span><span class="w" id="mwEF8"> </span><span class="k" id="mwEGA">{</span> <span class="w" id="mwEGE"> </span><span class="c" id="mwEGI"># handle exceptions with an errorcode matching ListPattern1</span> <span class="k" id="mwEGM">}</span><span class="w" id="mwEGQ"> </span>trap<span class="w" id="mwEGU"> </span>ListPattern2<span class="w" id="mwEGY"> </span><span class="k" id="mwEGc">{</span><span class="nv" id="mwEGg">err</span><span class="w" id="mwEGk"> </span>opt<span class="k" id="mwEGo">}</span><span class="w" id="mwEGs"> </span><span class="k" id="mwEGw">{</span> <span class="w" id="mwEG0"> </span><span class="c" id="mwEG4"># ...</span> <span class="k" id="mwEG8">}</span><span class="w" id="mwEHA"> </span>on<span class="w" id="mwEHE"> </span>error<span class="w" id="mwEHI"> </span><span class="k" id="mwEHM">{</span><span class="nv" id="mwEHQ">err</span><span class="w" id="mwEHU"> </span>opt<span class="k" id="mwEHY">}</span><span class="w" id="mwEHc"> </span><span class="k" id="mwEHg">{</span> <span class="w" id="mwEHk"> </span><span class="c" id="mwEHo"># handle everything else.</span> <span class="k" id="mwEHs">}</span><span class="w" id="mwEHw"> </span>finally<span class="w" id="mwEH0"> </span><span class="k" id="mwEH4">{</span> <span class="w" id="mwEH8"> </span><span class="c" id="mwEIA"># run whatever commands must run after the try-block.</span> <span class="k" id="mwEIE">}</span>VBScript
<span id="mwEIc"></span><span class="k" id="mwEIg">With</span><span class="w" id="mwEIk"> </span><span class="k" id="mwEIo">New</span><span class="w" id="mwEIs"> </span><span class="k" id="mwEIw">Try</span><span class="p" id="mwEI0">:</span><span class="w" id="mwEI4"> </span><span class="k" id="mwEI8">On</span><span class="w" id="mwEJA"> </span><span class="k" id="mwEJE">Error</span><span class="w" id="mwEJI"> </span><span class="k" id="mwEJM">Resume</span><span class="w" id="mwEJQ"> </span><span class="k" id="mwEJU">Next</span> <span class="w" id="mwEJY"> </span><span class="c" id="mwEJc">'do Something (only one statement recommended)</span> <span class="p" id="mwEJg">.</span><span class="n" id="mwEJk">Catch</span><span class="p" id="mwEJo">:</span><span class="w" id="mwEJs"> </span><span class="k" id="mwEJw">On</span><span class="w" id="mwEJ0"> </span><span class="k" id="mwEJ4">Error</span><span class="w" id="mwEJ8"> </span><span class="k" id="mwEKA">GoTo</span><span class="w" id="mwEKE"> </span><span class="mi" id="mwEKI">0</span><span class="p" id="mwEKM">:</span><span class="w" id="mwEKQ"> </span><span class="k" id="mwEKU">Select</span><span class="w" id="mwEKY"> </span><span class="k" id="mwEKc">Case</span><span class="w" id="mwEKg"> </span><span class="p" id="mwEKk">.</span><span class="n" id="mwEKo">Number</span> <span class="w" id="mwEKs"> </span><span class="k" id="mwEKw">Case</span><span class="w" id="mwEK0"> </span><span class="mi" id="mwEK4">0</span><span class="w" id="mwEK8"> </span><span class="c" id="mwELA">'this line is required when using 'Case Else' clause because of the lack of "Is" keyword in VBScript Case statement</span> <span class="w" id="mwELE"> </span><span class="c" id="mwELI">'no exception</span> <span class="w" id="mwELM"> </span><span class="k" id="mwELQ">Case</span><span class="w" id="mwELU"> </span><span class="n" id="mwELY">SOME_ERRORNUMBER</span> <span class="w" id="mwELc"> </span><span class="c" id="mwELg">'exception handling</span> <span class="w" id="mwELk"> </span><span class="k" id="mwELo">Case</span><span class="w" id="mwELs"> </span><span class="k" id="mwELw">Else</span> <span class="w" id="mwEL0"> </span><span class="c" id="mwEL4">'unknown exception</span> <span class="k" id="mwEL8">End</span><span class="w" id="mwEMA"> </span><span class="k" id="mwEME">Select</span><span class="p" id="mwEMI">:</span><span class="w" id="mwEMM"> </span><span class="k" id="mwEMQ">End</span><span class="w" id="mwEMU"> </span><span class="k" id="mwEMY">With</span> <span class="c" id="mwEMc">' *** Try Class ***</span> <span class="k" id="mwEMg">Class</span><span class="w" id="mwEMk"> </span><span class="nc" id="mwEMo">Try</span> <span class="w" id="mwEMs"> </span><span class="k" id="mwEMw">Private</span><span class="w" id="mwEM0"> </span><span class="n" id="mwEM4">mstrDescription</span> <span class="w" id="mwEM8"> </span><span class="k" id="mwENA">Private</span><span class="w" id="mwENE"> </span><span class="n" id="mwENI">mlngHelpContext</span> <span class="w" id="mwENM"> </span><span class="k" id="mwENQ">Private</span><span class="w" id="mwENU"> </span><span class="n" id="mwENY">mstrHelpFile</span> <span class="w" id="mwENc"> </span><span class="k" id="mwENg">Private</span><span class="w" id="mwENk"> </span><span class="n" id="mwENo">mlngNumber</span> <span class="w" id="mwENs"> </span><span class="k" id="mwENw">Private</span><span class="w" id="mwEN0"> </span><span class="n" id="mwEN4">mstrSource</span> <span class="w" id="mwEN8"> </span><span class="k" id="mwEOA">Public</span><span class="w" id="mwEOE"> </span><span class="k" id="mwEOI">Sub</span><span class="w" id="mwEOM"> </span><span class="nf" id="mwEOQ">Catch</span><span class="p" id="mwEOU">()</span> <span class="w" id="mwEOY"> </span><span class="n" id="mwEOc">mstrDescription</span><span class="w" id="mwEOg"> </span><span class="o" id="mwEOk">=</span><span class="w" id="mwEOo"> </span><span class="n" id="mwEOs">Err</span><span class="p" id="mwEOw">.</span><span class="n" id="mwEO0">Description</span> <span class="w" id="mwEO4"> </span><span class="n" id="mwEO8">mlngHelpContext</span><span class="w" id="mwEPA"> </span><span class="o" id="mwEPE">=</span><span class="w" id="mwEPI"> </span><span class="n" id="mwEPM">Err</span><span class="p" id="mwEPQ">.</span><span class="n" id="mwEPU">HelpContext</span> <span class="w" id="mwEPY"> </span><span class="n" id="mwEPc">mstrHelpFile</span><span class="w" id="mwEPg"> </span><span class="o" id="mwEPk">=</span><span class="w" id="mwEPo"> </span><span class="n" id="mwEPs">Err</span><span class="p" id="mwEPw">.</span><span class="n" id="mwEP0">HelpFile</span> <span class="w" id="mwEP4"> </span><span class="n" id="mwEP8">mlngNumber</span><span class="w" id="mwEQA"> </span><span class="o" id="mwEQE">=</span><span class="w" id="mwEQI"> </span><span class="n" id="mwEQM">Err</span><span class="p" id="mwEQQ">.</span><span class="n" id="mwEQU">Number</span> <span class="w" id="mwEQY"> </span><span class="n" id="mwEQc">mstrSource</span><span class="w" id="mwEQg"> </span><span class="o" id="mwEQk">=</span><span class="w" id="mwEQo"> </span><span class="n" id="mwEQs">Err</span><span class="p" id="mwEQw">.</span><span class="n" id="mwEQ0">Source</span> <span class="w" id="mwEQ4"> </span><span class="k" id="mwEQ8">End</span><span class="w" id="mwERA"> </span><span class="k" id="mwERE">Sub</span> <span class="w" id="mwERI"> </span><span class="k" id="mwERM">Public</span><span class="w" id="mwERQ"> </span><span class="k" id="mwERU">Property</span><span class="w" id="mwERY"> </span><span class="nf" id="mwERc">Get</span><span class="w" id="mwERg"> </span><span class="n" id="mwERk">Source</span><span class="p" id="mwERo">()</span> <span class="w" id="mwERs"> </span><span class="n" id="mwERw">Source</span><span class="w" id="mwER0"> </span><span class="o" id="mwER4">=</span><span class="w" id="mwER8"> </span><span class="n" id="mwESA">mstrSource</span> <span class="w" id="mwESE"> </span><span class="k" id="mwESI">End</span><span class="w" id="mwESM"> </span><span class="k" id="mwESQ">Property</span> <span class="w" id="mwESU"> </span> <span class="w" id="mwESY"> </span><span class="k" id="mwESc">Public</span><span class="w" id="mwESg"> </span><span class="k" id="mwESk">Property</span><span class="w" id="mwESo"> </span><span class="nf" id="mwESs">Get</span><span class="w" id="mwESw"> </span><span class="n" id="mwES0">Number</span><span class="p" id="mwES4">()</span> <span class="w" id="mwES8"> </span><span class="n" id="mwETA">Number</span><span class="w" id="mwETE"> </span><span class="o" id="mwETI">=</span><span class="w" id="mwETM"> </span><span class="n" id="mwETQ">mlngNumber</span> <span class="w" id="mwETU"> </span><span class="k" id="mwETY">End</span><span class="w" id="mwETc"> </span><span class="k" id="mwETg">Property</span> <span class="w" id="mwETk"> </span><span class="k" id="mwETo">Public</span><span class="w" id="mwETs"> </span><span class="k" id="mwETw">Property</span><span class="w" id="mwET0"> </span><span class="nf" id="mwET4">Get</span><span class="w" id="mwET8"> </span><span class="n" id="mwEUA">HelpFile</span><span class="p" id="mwEUE">()</span> <span class="w" id="mwEUI"> </span><span class="n" id="mwEUM">HelpFile</span><span class="w" id="mwEUQ"> </span><span class="o" id="mwEUU">=</span><span class="w" id="mwEUY"> </span><span class="n" id="mwEUc">mstrHelpFile</span> <span class="w" id="mwEUg"> </span><span class="k" id="mwEUk">End</span><span class="w" id="mwEUo"> </span><span class="k" id="mwEUs">Property</span> <span class="w" id="mwEUw"> </span> <span class="w" id="mwEU0"> </span><span class="k" id="mwEU4">Public</span><span class="w" id="mwEU8"> </span><span class="k" id="mwEVA">Property</span><span class="w" id="mwEVE"> </span><span class="nf" id="mwEVI">Get</span><span class="w" id="mwEVM"> </span><span class="n" id="mwEVQ">HelpContext</span><span class="p" id="mwEVU">()</span> <span class="w" id="mwEVY"> </span><span class="n" id="mwEVc">HelpContext</span><span class="w" id="mwEVg"> </span><span class="o" id="mwEVk">=</span><span class="w" id="mwEVo"> </span><span class="n" id="mwEVs">mlngHelpContext</span> <span class="w" id="mwEVw"> </span><span class="k" id="mwEV0">End</span><span class="w" id="mwEV4"> </span><span class="k" id="mwEV8">Property</span> <span class="w" id="mwEWA"> </span> <span class="w" id="mwEWE"> </span><span class="k" id="mwEWI">Public</span><span class="w" id="mwEWM"> </span><span class="k" id="mwEWQ">Property</span><span class="w" id="mwEWU"> </span><span class="nf" id="mwEWY">Get</span><span class="w" id="mwEWc"> </span><span class="n" id="mwEWg">Description</span><span class="p" id="mwEWk">()</span> <span class="w" id="mwEWo"> </span><span class="n" id="mwEWs">Description</span><span class="w" id="mwEWw"> </span><span class="o" id="mwEW0">=</span><span class="w" id="mwEW4"> </span><span class="n" id="mwEW8">mstrDescription</span> <span class="w" id="mwEXA"> </span><span class="k" id="mwEXE">End</span><span class="w" id="mwEXI"> </span><span class="k" id="mwEXM">Property</span> <span class="k" id="mwEXQ">End</span><span class="w" id="mwEXU"> </span><span class="k" id="mwEXY">Class</span>
Visual Basic 6
Exception handling syntax is very similar to Basic. Error handling is local on each procedure.
<span id="mwEYI"></span><span class="k" id="mwEYM">On</span><span class="w" id="mwEYQ"> </span><span class="k" id="mwEYU">Error</span><span class="w" id="mwEYY"> </span><span class="k" id="mwEYc">GoTo</span><span class="w" id="mwEYg"> </span><span class="n" id="mwEYk">HandlerLabel</span><span class="w" id="mwEYo"> </span><span class="c" id="mwEYs">'When error has occurred jumps to HandlerLabel, which is defined anywhere within Function or Sub</span> <span class="c" id="mwEYw">'or</span> <span class="k" id="mwEY0">On</span><span class="w" id="mwEY4"> </span><span class="k" id="mwEY8">Error</span><span class="w" id="mwEZA"> </span><span class="k" id="mwEZE">GoTo</span><span class="w" id="mwEZI"> </span><span class="mi" id="mwEZM">0</span><span class="w" id="mwEZQ"> </span><span class="c" id="mwEZU">'switch off error handling. Error causes fatal runtime error and stops application</span> <span class="c" id="mwEZY">'or</span> <span class="k" id="mwEZc">On</span><span class="w" id="mwEZg"> </span><span class="k" id="mwEZk">Error</span><span class="w" id="mwEZo"> </span><span class="k" id="mwEZs">Resume</span><span class="w" id="mwEZw"> </span><span class="k" id="mwEZ0">Next</span><span class="w" id="mwEZ4"> </span><span class="c" id="mwEZ8">'Object Err is set, but execution continues on next command. You can still use Err object to check error state.</span> <span class="c" id="mwEaA">'...</span> <span class="n" id="mwEaE">Err</span><span class="p" id="mwEaI">.</span><span class="n" id="mwEaM">Raise</span><span class="w" id="mwEaQ"> </span><span class="mi" id="mwEaU">6</span><span class="w" id="mwEaY"> </span><span class="c" id="mwEac">' Generate an "Overflow" error using built-in object Err. If there is no error handler, calling procedure can catch exception by same syntax</span> <span class="c" id="mwEag">'...</span> <span class="n" id="mwEak">FinallyLabel</span><span class="p" id="mwEao">:</span><span class="w" id="mwEas"> </span><span class="c" id="mwEaw">'just common label within procedure (non official emulation of Finally section from other languages)</span> <span class="w" id="mwEa0"> </span><span class="c" id="mwEa4">'cleanup code, always executed</span> <span class="k" id="mwEa8">Exit</span><span class="w" id="mwEbA"> </span><span class="k" id="mwEbE">Sub</span><span class="w" id="mwEbI"> </span><span class="err" id="mwEbM">'</span><span class="nf" id="mwEbQ">exits</span><span class="w" id="mwEbU"> </span><span class="n" id="mwEbY">procedure</span> <span class="c" id="mwEbc">'because we are after Exit Sub statement, next code is hidden for non-error execution</span> <span class="n" id="mwEbg">HandlerLabel</span><span class="p" id="mwEbk">:</span><span class="w" id="mwEbo"> </span><span class="c" id="mwEbs">'defines a common label, here used for exception handling.</span> <span class="k" id="mwEbw">If</span><span class="w" id="mwEb0"> </span><span class="n" id="mwEb4">Err</span><span class="p" id="mwEb8">.</span><span class="n" id="mwEcA">Number</span><span class="w" id="mwEcE"> </span><span class="o" id="mwEcI">=</span><span class="w" id="mwEcM"> </span><span class="mi" id="mwEcQ">6</span><span class="w" id="mwEcU"> </span><span class="k" id="mwEcY">Then</span><span class="w" id="mwEcc"> </span><span class="c" id="mwEcg">'Select Case statement is typically better solution</span> <span class="w" id="mwEck"> </span><span class="k" id="mwEco">Resume</span><span class="w" id="mwEcs"> </span><span class="n" id="mwEcw">FinallyLabel</span><span class="w" id="mwEc0"> </span><span class="c" id="mwEc4">'continue execution on specific label. Typically something with meaning of "Finally" in other languages</span> <span class="w" id="mwEc8"> </span><span class="c" id="mwEdA">'or</span> <span class="w" id="mwEdE"> </span><span class="k" id="mwEdI">Resume</span><span class="w" id="mwEdM"> </span><span class="k" id="mwEdQ">Next</span><span class="w" id="mwEdU"> </span><span class="c" id="mwEdY">'continue execution on statement next to "Err.Raise 6"</span> <span class="w" id="mwEdc"> </span><span class="c" id="mwEdg">'or</span> <span class="w" id="mwEdk"> </span><span class="k" id="mwEdo">Resume</span><span class="w" id="mwEds"> </span><span class="c" id="mwEdw">'continue execution on (repeat) statement "Err.Raise 6"</span> <span class="k" id="mwEd0">End</span><span class="w" id="mwEd4"> </span><span class="k" id="mwEd8">If</span> <span class="n" id="mwEeA">MsgBox</span><span class="w" id="mwEeE"> </span><span class="n" id="mwEeI">Err</span><span class="p" id="mwEeM">.</span><span class="n" id="mwEeQ">Number</span><span class="w" id="mwEeU"> </span><span class="o" id="mwEeY">&</span><span class="w" id="mwEec"> </span><span class="s" id="mwEeg">" "</span><span class="w" id="mwEek"> </span><span class="o" id="mwEeo">&</span><span class="w" id="mwEes"> </span><span class="n" id="mwEew">Err</span><span class="p" id="mwEe0">.</span><span class="n" id="mwEe4">Source</span><span class="w" id="mwEe8"> </span><span class="o" id="mwEfA">&</span><span class="w" id="mwEfE"> </span><span class="s" id="mwEfI">" "</span><span class="w" id="mwEfM"> </span><span class="o" id="mwEfQ">&</span><span class="w" id="mwEfU"> </span><span class="n" id="mwEfY">Erl</span><span class="w" id="mwEfc"> </span><span class="o" id="mwEfg">&</span><span class="w" id="mwEfk"> </span><span class="s" id="mwEfo">" "</span><span class="w" id="mwEfs"> </span><span class="o" id="mwEfw">&</span><span class="w" id="mwEf0"> </span><span class="n" id="mwEf4">Err</span><span class="p" id="mwEf8">.</span><span class="n" id="mwEgA">Description</span><span class="w" id="mwEgE"> </span><span class="o" id="mwEgI">&</span><span class="w" id="mwEgM"> </span><span class="s" id="mwEgQ">" "</span><span class="w" id="mwEgU"> </span><span class="o" id="mwEgY">&</span><span class="w" id="mwEgc"> </span><span class="n" id="mwEgg">Err</span><span class="p" id="mwEgk">.</span><span class="n" id="mwEgo">LastDllError</span><span class="w" id="mwEgs"> </span><span class="c" id="mwEgw">'show message box with important error properties</span> <span class="w" id="mwEg0"> </span><span class="c" id="mwEg4">'Erl is VB6 built-in line number global variable (if used). Typically is used some kind of IDE Add-In, which labels every code line with number before compilation</span> <span class="k" id="mwEg8">Resume</span><span class="w" id="mwEhA"> </span><span class="n" id="mwEhE">FinallyLabel</span>
Example of specific (non official) implementation of exception handling, which uses object of class "Try".
<span id="mwEhU"></span><span class="k" id="mwEhY">With</span><span class="w" id="mwEhc"> </span><span class="k" id="mwEhg">New</span><span class="w" id="mwEhk"> </span><span class="k" id="mwEho">Try</span><span class="p" id="mwEhs">:</span><span class="w" id="mwEhw"> </span><span class="k" id="mwEh0">On</span><span class="w" id="mwEh4"> </span><span class="k" id="mwEh8">Error</span><span class="w" id="mwEiA"> </span><span class="k" id="mwEiE">Resume</span><span class="w" id="mwEiI"> </span><span class="k" id="mwEiM">Next</span><span class="w" id="mwEiQ"> </span><span class="c" id="mwEiU">'Create new object of class "Try" and use it. Then set this object as default. Can be "Dim T As New Try: ... ... T.Catch</span> <span class="w" id="mwEiY"> </span><span class="c" id="mwEic">'do Something (only one statement recommended)</span> <span class="p" id="mwEig">.</span><span class="n" id="mwEik">Catch</span><span class="p" id="mwEio">:</span><span class="w" id="mwEis"> </span><span class="k" id="mwEiw">On</span><span class="w" id="mwEi0"> </span><span class="k" id="mwEi4">Error</span><span class="w" id="mwEi8"> </span><span class="k" id="mwEjA">GoTo</span><span class="w" id="mwEjE"> </span><span class="mi" id="mwEjI">0</span><span class="p" id="mwEjM">:</span><span class="w" id="mwEjQ"> </span><span class="k" id="mwEjU">Select</span><span class="w" id="mwEjY"> </span><span class="k" id="mwEjc">Case</span><span class="w" id="mwEjg"> </span><span class="p" id="mwEjk">.</span><span class="n" id="mwEjo">Number</span><span class="w" id="mwEjs"> </span><span class="c" id="mwEjw">'Call Try.Catch() procedure. Then switch off error handling. Then use "switch-like" statement on result of Try.Number property (value of property Err.Number of built-in Err object)</span> <span class="w" id="mwEj0"> </span><span class="k" id="mwEj4">Case</span><span class="w" id="mwEj8"> </span><span class="n" id="mwEkA">SOME_ERRORNUMBER</span> <span class="w" id="mwEkE"> </span><span class="c" id="mwEkI">'exception handling</span> <span class="w" id="mwEkM"> </span><span class="k" id="mwEkQ">Case</span><span class="w" id="mwEkU"> </span><span class="ow" id="mwEkY">Is</span><span class="w" id="mwEkc"> </span><span class="o" id="mwEkg"><></span><span class="w" id="mwEkk"> </span><span class="mi" id="mwEko">0</span><span class="w" id="mwEks"> </span><span class="c" id="mwEkw">'When Err.Number is zero, no error has occurred</span> <span class="w" id="mwEk0"> </span><span class="c" id="mwEk4">'unknown exception</span> <span class="k" id="mwEk8">End</span><span class="w" id="mwElA"> </span><span class="k" id="mwElE">Select</span><span class="p" id="mwElI">:</span><span class="w" id="mwElM"> </span><span class="k" id="mwElQ">End</span><span class="w" id="mwElU"> </span><span class="k" id="mwElY">With</span> <span class="c" id="mwElc">' *** Try Class ***</span> <span class="k" id="mwElg">Private</span><span class="w" id="mwElk"> </span><span class="n" id="mwElo">mstrDescription</span><span class="w" id="mwEls"> </span><span class="ow" id="mwElw">As</span><span class="w" id="mwEl0"> </span><span class="kt" id="mwEl4">String</span> <span class="k" id="mwEl8">Private</span><span class="w" id="mwEmA"> </span><span class="n" id="mwEmE">mlngHelpContext</span><span class="w" id="mwEmI"> </span><span class="ow" id="mwEmM">As</span><span class="w" id="mwEmQ"> </span><span class="kt" id="mwEmU">Long</span> <span class="k" id="mwEmY">Private</span><span class="w" id="mwEmc"> </span><span class="n" id="mwEmg">mstrHelpFile</span><span class="w" id="mwEmk"> </span><span class="ow" id="mwEmo">As</span><span class="w" id="mwEms"> </span><span class="kt" id="mwEmw">String</span> <span class="k" id="mwEm0">Private</span><span class="w" id="mwEm4"> </span><span class="n" id="mwEm8">mlngLastDllError</span><span class="w" id="mwEnA"> </span><span class="ow" id="mwEnE">As</span><span class="w" id="mwEnI"> </span><span class="kt" id="mwEnM">Long</span> <span class="k" id="mwEnQ">Private</span><span class="w" id="mwEnU"> </span><span class="n" id="mwEnY">mlngNumber</span><span class="w" id="mwEnc"> </span><span class="ow" id="mwEng">As</span><span class="w" id="mwEnk"> </span><span class="kt" id="mwEno">Long</span> <span class="k" id="mwEns">Private</span><span class="w" id="mwEnw"> </span><span class="n" id="mwEn0">mstrSource</span><span class="w" id="mwEn4"> </span><span class="ow" id="mwEn8">As</span><span class="w" id="mwEoA"> </span><span class="kt" id="mwEoE">String</span> <span class="k" id="mwEoI">Public</span><span class="w" id="mwEoM"> </span><span class="k" id="mwEoQ">Sub</span><span class="w" id="mwEoU"> </span><span class="nf" id="mwEoY">Catch</span><span class="p" id="mwEoc">()</span> <span class="w" id="mwEog"> </span><span class="n" id="mwEok">mstrDescription</span><span class="w" id="mwEoo"> </span><span class="o" id="mwEos">=</span><span class="w" id="mwEow"> </span><span class="n" id="mwEo0">Err</span><span class="p" id="mwEo4">.</span><span class="n" id="mwEo8">Description</span> <span class="w" id="mwEpA"> </span><span class="n" id="mwEpE">mlngHelpContext</span><span class="w" id="mwEpI"> </span><span class="o" id="mwEpM">=</span><span class="w" id="mwEpQ"> </span><span class="n" id="mwEpU">Err</span><span class="p" id="mwEpY">.</span><span class="n" id="mwEpc">HelpContext</span> <span class="w" id="mwEpg"> </span><span class="n" id="mwEpk">mstrHelpFile</span><span class="w" id="mwEpo"> </span><span class="o" id="mwEps">=</span><span class="w" id="mwEpw"> </span><span class="n" id="mwEp0">Err</span><span class="p" id="mwEp4">.</span><span class="n" id="mwEp8">HelpFile</span> <span class="w" id="mwEqA"> </span><span class="n" id="mwEqE">mlngLastDllError</span><span class="w" id="mwEqI"> </span><span class="o" id="mwEqM">=</span><span class="w" id="mwEqQ"> </span><span class="n" id="mwEqU">Err</span><span class="p" id="mwEqY">.</span><span class="n" id="mwEqc">LastDllError</span> <span class="w" id="mwEqg"> </span><span class="n" id="mwEqk">mlngNumber</span><span class="w" id="mwEqo"> </span><span class="o" id="mwEqs">=</span><span class="w" id="mwEqw"> </span><span class="n" id="mwEq0">Err</span><span class="p" id="mwEq4">.</span><span class="n" id="mwEq8">Number</span> <span class="w" id="mwErA"> </span><span class="n" id="mwErE">mstrSource</span><span class="w" id="mwErI"> </span><span class="o" id="mwErM">=</span><span class="w" id="mwErQ"> </span><span class="n" id="mwErU">Err</span><span class="p" id="mwErY">.</span><span class="n" id="mwErc">Source</span> <span class="k" id="mwErg">End</span><span class="w" id="mwErk"> </span><span class="k" id="mwEro">Sub</span> <span class="k" id="mwErs">Public</span><span class="w" id="mwErw"> </span><span class="k" id="mwEr0">Property</span><span class="w" id="mwEr4"> </span><span class="nf" id="mwEr8">Get</span><span class="w" id="mwEsA"> </span><span class="n" id="mwEsE">Source</span><span class="p" id="mwEsI">()</span><span class="w" id="mwEsM"> </span><span class="ow" id="mwEsQ">As</span><span class="w" id="mwEsU"> </span><span class="kt" id="mwEsY">String</span> <span class="w" id="mwEsc"> </span><span class="n" id="mwEsg">Source</span><span class="w" id="mwEsk"> </span><span class="o" id="mwEso">=</span><span class="w" id="mwEss"> </span><span class="n" id="mwEsw">mstrSource</span> <span class="k" id="mwEs0">End</span><span class="w" id="mwEs4"> </span><span class="k" id="mwEs8">Property</span> <span class="k" id="mwEtA">Public</span><span class="w" id="mwEtE"> </span><span class="k" id="mwEtI">Property</span><span class="w" id="mwEtM"> </span><span class="nf" id="mwEtQ">Get</span><span class="w" id="mwEtU"> </span><span class="n" id="mwEtY">Number</span><span class="p" id="mwEtc">()</span><span class="w" id="mwEtg"> </span><span class="ow" id="mwEtk">As</span><span class="w" id="mwEto"> </span><span class="kt" id="mwEts">Long</span> <span class="w" id="mwEtw"> </span><span class="n" id="mwEt0">Number</span><span class="w" id="mwEt4"> </span><span class="o" id="mwEt8">=</span><span class="w" id="mwEuA"> </span><span class="n" id="mwEuE">mlngNumber</span> <span class="k" id="mwEuI">End</span><span class="w" id="mwEuM"> </span><span class="k" id="mwEuQ">Property</span> <span class="k" id="mwEuU">Public</span><span class="w" id="mwEuY"> </span><span class="k" id="mwEuc">Property</span><span class="w" id="mwEug"> </span><span class="nf" id="mwEuk">Get</span><span class="w" id="mwEuo"> </span><span class="n" id="mwEus">LastDllError</span><span class="p" id="mwEuw">()</span><span class="w" id="mwEu0"> </span><span class="ow" id="mwEu4">As</span><span class="w" id="mwEu8"> </span><span class="kt" id="mwEvA">Long</span> <span class="w" id="mwEvE"> </span><span class="n" id="mwEvI">LastDllError</span><span class="w" id="mwEvM"> </span><span class="o" id="mwEvQ">=</span><span class="w" id="mwEvU"> </span><span class="n" id="mwEvY">mlngLastDllError</span> <span class="k" id="mwEvc">End</span><span class="w" id="mwEvg"> </span><span class="k" id="mwEvk">Property</span> <span class="k" id="mwEvo">Public</span><span class="w" id="mwEvs"> </span><span class="k" id="mwEvw">Property</span><span class="w" id="mwEv0"> </span><span class="nf" id="mwEv4">Get</span><span class="w" id="mwEv8"> </span><span class="n" id="mwEwA">HelpFile</span><span class="p" id="mwEwE">()</span><span class="w" id="mwEwI"> </span><span class="ow" id="mwEwM">As</span><span class="w" id="mwEwQ"> </span><span class="kt" id="mwEwU">String</span> <span class="w" id="mwEwY"> </span><span class="n" id="mwEwc">HelpFile</span><span class="w" id="mwEwg"> </span><span class="o" id="mwEwk">=</span><span class="w" id="mwEwo"> </span><span class="n" id="mwEws">mstrHelpFile</span> <span class="k" id="mwEww">End</span><span class="w" id="mwEw0"> </span><span class="k" id="mwEw4">Property</span> <span class="k" id="mwEw8">Public</span><span class="w" id="mwExA"> </span><span class="k" id="mwExE">Property</span><span class="w" id="mwExI"> </span><span class="nf" id="mwExM">Get</span><span class="w" id="mwExQ"> </span><span class="n" id="mwExU">HelpContext</span><span class="p" id="mwExY">()</span><span class="w" id="mwExc"> </span><span class="ow" id="mwExg">As</span><span class="w" id="mwExk"> </span><span class="kt" id="mwExo">Long</span> <span class="w" id="mwExs"> </span><span class="n" id="mwExw">HelpContext</span><span class="w" id="mwEx0"> </span><span class="o" id="mwEx4">=</span><span class="w" id="mwEx8"> </span><span class="n" id="mwEyA">mlngHelpContext</span> <span class="k" id="mwEyE">End</span><span class="w" id="mwEyI"> </span><span class="k" id="mwEyM">Property</span> <span class="k" id="mwEyQ">Public</span><span class="w" id="mwEyU"> </span><span class="k" id="mwEyY">Property</span><span class="w" id="mwEyc"> </span><span class="nf" id="mwEyg">Get</span><span class="w" id="mwEyk"> </span><span class="n" id="mwEyo">Description</span><span class="p" id="mwEys">()</span><span class="w" id="mwEyw"> </span><span class="ow" id="mwEy0">As</span><span class="w" id="mwEy4"> </span><span class="kt" id="mwEy8">String</span> <span class="w" id="mwEzA"> </span><span class="n" id="mwEzE">Description</span><span class="w" id="mwEzI"> </span><span class="o" id="mwEzM">=</span><span class="w" id="mwEzQ"> </span><span class="n" id="mwEzU">mstrDescription</span> <span class="k" id="mwEzY">End</span><span class="w" id="mwEzc"> </span><span class="k" id="mwEzg">Property</span>
Visual Basic .NET
A Try block must have at least one clause Catch or Finally clause and at most one Finally clause.
<span id="mwE0g"></span><span class="k" id="mwE0k">Try</span> <span class="w" id="mwE0o"> </span><span class="c" id="mwE0s">' code to be executed here</span> <span class="k" id="mwE0w">Catch</span><span class="w" id="mwE00"> </span><span class="n" id="mwE04">ex</span><span class="w" id="mwE08"> </span><span class="ow" id="mwE1A">As</span><span class="w" id="mwE1E"> </span><span class="n" id="mwE1I">Exception</span><span class="w" id="mwE1M"> </span><span class="k" id="mwE1Q">When</span><span class="w" id="mwE1U"> </span><span class="n" id="mwE1Y">condition</span> <span class="w" id="mwE1c"> </span><span class="c" id="mwE1g">' Handle Exception when a specific condition is true. The exception object is stored in "ex".</span> <span class="k" id="mwE1k">Catch</span><span class="w" id="mwE1o"> </span><span class="n" id="mwE1s">ex</span><span class="w" id="mwE1w"> </span><span class="ow" id="mwE10">As</span><span class="w" id="mwE14"> </span><span class="n" id="mwE18">ExceptionType</span> <span class="w" id="mwE2A"> </span><span class="c" id="mwE2E">' Handle Exception of a specified type (i.e. DivideByZeroException, OverflowException, etc.)</span> <span class="k" id="mwE2I">Catch</span><span class="w" id="mwE2M"> </span><span class="n" id="mwE2Q">ex</span><span class="w" id="mwE2U"> </span><span class="ow" id="mwE2Y">As</span><span class="w" id="mwE2c"> </span><span class="n" id="mwE2g">Exception</span> <span class="w" id="mwE2k"> </span><span class="c" id="mwE2o">' Handle Exception (catch all exceptions of a type not previously specified)</span> <span class="k" id="mwE2s">Catch</span> <span class="w" id="mwE2w"> </span><span class="c" id="mwE20">' Handles anything that might be thrown, including non-CLR exceptions.</span> <span class="k" id="mwE24">Finally</span> <span class="w" id="mwE28"> </span><span class="c" id="mwE3A">' Always run when leaving the try block (including catch clauses), regardless of whether any exceptions were thrown or whether they were handled.</span> <span class="w" id="mwE3E"> </span><span class="c" id="mwE3I">' Often used to clean up and close resources such a file handles.</span> <span class="w" id="mwE3M"> </span><span class="c" id="mwE3Q">' May not be run when Environment.FailFast() is called and in other system-wide exceptional conditions (e.g. power loss), or when the process crashes due to an exception in another thread.</span> <span class="k" id="mwE3U">End</span><span class="w" id="mwE3Y"> </span><span class="k" id="mwE3c">Try</span>
Visual Prolog
<span id="mwE30"></span><span class="k k-Minor" id="mwE34">try</span> <span class="w" id="mwE38"> </span><span class="c" id="mwE4A">% Block to protect</span> <span class="k k-Minor" id="mwE4E">catch</span><span class="w" id="mwE4I"> </span><span class="nv" id="mwE4M">TraceId</span><span class="w" id="mwE4Q"> </span><span class="k k-Minor" id="mwE4U">do</span> <span class="w" id="mwE4Y"> </span><span class="c" id="mwE4c">% Code to execute in the event of an exception; TraceId gives access to the exception information</span> <span class="k k-Minor" id="mwE4g">finally</span> <span class="w" id="mwE4k"> </span><span class="c" id="mwE4o">% Code will be executed regardles however the other parts behave</span> <span class="k k-Minor" id="mwE4s">end try</span>
X++
<span id="mwE5Y"></span><span class="k" id="mwE5c">public</span><span class="w" id="mwE5g"> </span><span class="k" id="mwE5k">static</span><span class="w" id="mwE5o"> </span><span class="k" id="mwE5s">void</span><span class="w" id="mwE5w"> </span><span class="nf" id="mwE50">Main</span><span class="p" id="mwE54">(</span><span class="n" id="mwE58">Args</span><span class="w" id="mwE6A"> </span><span class="n" id="mwE6E">_args</span><span class="p" id="mwE6I">)</span> <span class="p" id="mwE6M">{</span> <span class="w" id="mwE6Q"> </span><span class="k" id="mwE6U">try</span> <span class="w" id="mwE6Y"> </span><span class="p" id="mwE6c">{</span> <span class="w" id="mwE6g"> </span><span class="c1" id="mwE6k">// Code that could throw an exception.</span> <span class="w" id="mwE6o"> </span><span class="p" id="mwE6s">}</span> <span class="w" id="mwE6w"> </span><span class="k" id="mwE60">catch</span><span class="w" id="mwE64"> </span><span class="p" id="mwE68">(</span><span class="vc" id="mwE7A">Exception</span><span class="p" id="mwE7E">::</span><span class="n" id="mwE7I">Error</span><span class="p" id="mwE7M">)</span><span class="w" id="mwE7Q"> </span><span class="c1" id="mwE7U">// Or any other exception type.</span> <span class="w" id="mwE7Y"> </span><span class="p" id="mwE7c">{</span> <span class="w" id="mwE7g"> </span><span class="c1" id="mwE7k">// Process the error.</span> <span class="w" id="mwE7o"> </span><span class="p" id="mwE7s">}</span> <span class="w" id="mwE7w"> </span><span class="k" id="mwE70">catch</span> <span class="w" id="mwE74"> </span><span class="p" id="mwE78">{</span> <span class="w" id="mwE8A"> </span><span class="c1" id="mwE8E">// Process any other exception type not handled previously.</span> <span class="w" id="mwE8I"> </span><span class="p" id="mwE8M">}</span> <span class="w" id="mwE8Q"> </span><span class="c1" id="mwE8U">// Code here will execute as long as any exception is caught.</span> <span class="p" id="mwE8Y">}</span>