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.

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

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.

Master TypeScript with Deep Grasping Methodology!

Learn More