Book 01 · Programming FundamentalsPage 19 of 56

Exception

Q: How do I handle errors with async/await?

Wrap the await calls in a try/catch block. Inside an async function, a rejected promise behaves like a thrown exception, so the catch block receives the error.

In Turkish: İstisna

Updated September 30, 20262 min read

In short

An exception is an event that interrupts a program's normal flow when an error occurs, which code can catch and handle instead of letting the program crash.

What is an exception in programming?

An exception signals that something went wrong while the program was running, such as a missing file, a failed network request, or invalid input. When code throws (or raises) an exception, normal execution stops at that point. The program then looks for code that has declared it can handle the problem.

Exceptions travel up the call stack. If the function that threw the exception doesn't catch it, the function that called it gets a chance, then that function's caller, and so on. You handle exceptions by wrapping risky code in a try block and adding a catch block (called except in Python) that runs if an error occurs, plus an optional finally block that runs either way, which is useful for cleanup such as closing files. If nothing catches the exception, the program or request usually fails with an error message and a stack trace.

A fire alarm is a good analogy for an exception. When it goes off, everyone stops what they're doing and the people trained to deal with fires take over; if nobody responds, the whole building is evacuated. Exceptions let programs keep the main 'happy path' logic separate from the code that deals with problems.

Exceptions are often confused with errors in general. Syntax errors stop code from running at all, while exceptions happen at runtime and can be handled. Some languages, such as Go and Rust, prefer returning errors as ordinary values instead of throwing exceptions, which makes every possible failure visible in the code. Catching an exception and silently ignoring it is a common anti-pattern, because it hides bugs.

Key takeaways

An exception interrupts normal execution when an error occurs at runtime.
Code throws an exception, and a try/catch block can catch and handle it.
Uncaught exceptions move up the call stack and can crash the program.
A finally block runs whether or not an exception occurred, which suits cleanup work.
Only catch exceptions you can handle meaningfully; silently swallowing them hides bugs.

Example

Throwing and catching an exceptionjavascript

function parseAge(input) {
  const age = Number(input);
  if (Number.isNaN(age)) {
    throw new Error(`"${input}" is not a number`); // stop and signal a problem
  }
  return age;
}

try {
  parseAge("abc");
} catch (error) {
  console.error("Invalid input:", error.message); // handle the problem
} finally {
  console.log("Validation finished"); // always runs
}

Readers ask

What is the difference between an error and an exception?

The terms are often used interchangeably, and in many languages an exception is simply the object used to report a runtime error. Java also distinguishes Error, for serious problems an application shouldn't try to handle, such as running out of memory, from Exception, which code is expected to catch.

What is a stack trace?

A stack trace is the list of function calls that were active when an exception was thrown, printed with file names and line numbers. Reading it from the top shows where the problem happened and how the program got there.

How do I handle errors with async/await?

Wrap the await calls in a try/catch block. Inside an async function, a rejected promise behaves like a thrown exception, so the catch block receives the error.