> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# TypeScript Try-Catch-Finally
The `try...catch...finally` statement is a synchronous control flow construct used to handle runtime exceptions. It allows developers to execute potentially error-yielding code, intercept thrown exceptions to prevent program termination, and execute guaranteed cleanup operations regardless of the execution outcome.
```typescript theme={"dark"}
try {
// Statements that may throw an exception
} catch (error) {
// Statements executed if an exception is thrown
} finally {
// Statements executed unconditionally after try/catch
}
```
## Execution Mechanics
* **`try` Block:** Defines the lexical scope for exception monitoring. If an exception is thrown (via the `throw` keyword or an internal runtime error), execution immediately halts, and control flow transfers to the `catch` block.
* **`catch` Block:** Defines the exception handler. It binds the thrown exception to a local variable. If no exception is thrown in the `try` block, the `catch` block is skipped.
* **`finally` Block:** Defines the termination clause. It executes after the `try` and `catch` blocks complete. The `finally` block is guaranteed to execute even if the `try` or `catch` blocks contain `return`, `continue`, `break`, or `throw` statements.
## TypeScript-Specific Typing Rules
TypeScript introduces strict typing rules for the `catch` clause variable that differ from standard JavaScript:
1. **No Explicit Type Annotations:** You cannot explicitly annotate the type of the catch variable. Writing `catch (error: Error)` results in compiler error `TS1196: Catch clause variable type annotation must be 'any' or 'unknown' if specified`.
2. **The `unknown` Type:** By default (when `useUnknownInCatchVariables` is enabled in `tsconfig.json`, which is standard in modern TypeScript), the catch variable is implicitly typed as `unknown`. In older configurations, it defaulted to `any`.
3. **Type Narrowing:** Because the catch variable is `unknown`, TypeScript enforces type safety by requiring type guards (such as `instanceof` or `typeof`) to narrow the type before accessing its properties.
## Syntax Visualization with Type Narrowing
```typescript theme={"dark"}
try {
throw new Error("Execution failed");
} catch (error: unknown) { // Explicit 'unknown' is allowed, but implicit is standard
// Type narrowing is required to access properties safely
if (error instanceof Error) {
// TypeScript narrows 'error' to type 'Error'
console.error(error.message);
} else if (typeof error === "string") {
// TypeScript narrows 'error' to type 'string'
console.error(error.toUpperCase());
} else {
// Fallback for non-standard exceptions (e.g., throw 42, throw null)
console.error("An unexpected error type was thrown");
}
} finally {
// Executes unconditionally
console.log("Execution finalized");
}
```
## Omission of Blocks
The construct requires the `try` block and at least one of the subsequent blocks. It can be structured as:
* `try...catch`
* `try...finally`
* `try...catch...finally`
If `try...finally` is used without a `catch` block, the `finally` block will execute, but the exception will remain unhandled and will continue to propagate up the call stack immediately after the `finally` block completes.
Tired of Poor TypeScript Skills? Fix That With Deep Grasping!
Learn More
