Lesson 12 of 59

5 mins read

Error Handling: try, catch, on, finally & assert

In Plain English

Robust Dart applications handle runtime failures using `try`, `on ExceptionType`, `catch (e, stackTrace)`, and `finally`. Dart distinguishes between **Exceptions** (intended to be caught and handled, like `FormatException` or `SocketException`) and **Errors** (program bugs like `RangeError`). `assert()` statements enforce invariants in development mode with zero production overhead.

The Mental Model

"`try/catch` is like a trapeze safety net: you attempt a dangerous maneuver, and if you slip, the safety net catches you cleanly without halting the entire circus."

Deep Dive: How It Works

`on SpecificType`: Catches only designated exception subtypes without catching unrelated errors.

`catch (e, s)`: Binds the exception object `e` and the detailed execution `StackTrace s`.

`finally`: Block guaranteed to execute regardless of whether an exception occurred (ideal for closing streams/files).

`assert(expr, "message")`: Active only in debug mode; stripped out completely in AOT release builds.

Syntax Blueprint

try {
  var num = int.parse("invalid");
} on FormatException catch (e) {
  print("Invalid number: $e");
} catch (e, stackTrace) {
  print("Unknown error: $e");
} finally {
  print("Cleanup completed");
}

Typed exception handling with fallback and guaranteed finalizer.

Core Rules to Remember

Targeted on Catching: Catch specific error types with `on` rather than catching generic `Object`.

StackTrace Inspection: Pass second argument to `catch(e, s)` to capture stack traces for logging.

Zero Release Cost Asserts: `assert()` runs during development and is stripped in release compilation.

Common Beginner Traps & How to Fix Them

Mistake:Catching `dynamic` and swallowing all errors silently without logging.

Why it happens: Hides critical programming bugs (like `NoSuchMethodError` or `RangeError`).

How to fix: Catch specific exceptions with `on` and rethrow unexpected errors with `rethrow;`.

Pro Tip: Use `rethrow;` inside a catch block to preserve the original stack trace when logging and propagating exceptions.

Live Interactive Example

Hit Run Code to see it live

Typed Exception Handling with on, catch, and finally

Python 3.12

Output Console

Click "Run Code" to view the rendered output.

How it works: The FormatException was caught specifically by the on clause, followed by the guaranteed finally block.

Your Turn: Micro Challenge

No pressure! Edit the starter code below and test your solution with instant feedback.

Micro Exercise

Catch FormatException Safely

Wrap `int.parse("not_a_number")` in a `try` block.
Catch `on FormatException` and print `Caught FormatException`.
Add a `finally` block that prints `Done`.

Sandbox Output

Click "Run & Check" to test your solution.

Finished reading and practicing?

Mark this lesson as completed to update your course progress.