Exception Handling

Introduction

In the previous lesson, you saw PHP's traditional error system — notices, warnings, and fatal errors. Exceptions are PHP's more structured, modern way to handle problems: instead of an error simply appearing and possibly halting your script, you can catch it, inspect it, and decide exactly how your program should respond.

Exceptions are especially useful for expected, recoverable failure conditions — a division by zero, a failed file read, or invalid input — where you want your program to respond gracefully instead of crashing.

What Is an Exception?

An exception is an object that represents an error or unexpected condition. When something goes wrong, PHP code can "throw" an exception, which immediately stops normal execution and looks for a matching "catch" block to handle it. If no catch block is found anywhere, the script stops with a fatal error.

try, catch, and finally

The basic structure for handling exceptions is a try block, which contains code that might fail, followed by one or more catch blocks that handle specific problems, and an optional finally block that always runs regardless of what happened.

<?php
try {
    $result = 10 / 0;
} catch (DivisionByZeroError $e) {
    echo "Caught an error: " . $e->getMessage();
} finally {
    echo "\nThis always runs, error or not.";
}

Caught an error: Division by zero
This always runs, error or not.

The finally block is useful for cleanup work — like closing a file or a database connection — that needs to happen whether or not an exception occurred.

<?php
function processFile() {
    echo "Opening file...\n";
    try {
        throw new Exception("Something went wrong while reading.");
    } catch (Exception $e) {
        echo "Error: " . $e->getMessage() . "\n";
    } finally {
        echo "Closing file (always happens).";
    }
}

processFile();

Opening file...
Error: Something went wrong while reading.
Closing file (always happens).

Catching a Specific Exception Type

PHP has several built-in exception and error classes for common problems. Catching the specific type you expect, rather than a generic Exception, makes your intent clearer and prevents you from accidentally catching unrelated problems.

<?php
function divide(int $a, int $b): float {
    return $a / $b;
}

try {
    echo divide(10, 0);
} catch (DivisionByZeroError $e) {
    echo "Cannot divide by zero: " . $e->getMessage();
}

Cannot divide by zero: Division by zero

Throwing Your Own Exceptions

You are not limited to catching exceptions PHP throws automatically — you can throw your own using the throw keyword, anywhere your code detects a problem it cannot handle on the spot.

<?php
function withdraw(float $balance, float $amount): float {
    if ($amount > $balance) {
        throw new Exception("Insufficient funds.");
    }
    return $balance - $amount;
}

try {
    echo withdraw(100, 250);
} catch (Exception $e) {
    echo "Transaction failed: " . $e->getMessage();
}

Transaction failed: Insufficient funds.

Catching Multiple Exception Types

Sometimes the same block of code might fail in more than one way, and you want to handle several exception types with identical logic. PHP lets you list multiple types in a single catch block using the pipe (|) syntax.

<?php
function riskyOperation(int $choice) {
    if ($choice === 1) {
        throw new TypeError("Wrong type provided.");
    }
    throw new ValueError("Invalid value provided.");
}

try {
    riskyOperation(1);
} catch (TypeError | ValueError $e) {
    echo "Caught: " . get_class($e) . " - " . $e->getMessage();
}

Caught: TypeError - Wrong type provided.

This is useful when the recovery action is the same no matter which of the listed exceptions occurred, saving you from duplicating the same catch body multiple times.

Custom Exception Classes

Beyond throwing a plain Exception, PHP lets you define your own exception classes by extending the built-in Exception class. This lets you create meaningfully named exceptions, like InsufficientFundsException, that carry extra context specific to your application.

<?php
class InsufficientFundsException extends Exception {
}

try {
    throw new InsufficientFundsException("Balance too low for this withdrawal.");
} catch (InsufficientFundsException $e) {
    echo "Custom exception caught: " . $e->getMessage();
}

Custom exception caught: Balance too low for this withdrawal.

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Exception handling gives PHP a structured, predictable way to deal with problems your code can anticipate. With try, catch, and finally, you can respond to specific failure conditions gracefully, throw your own meaningful exceptions, and even handle several exception types at once.

Next, you will step back and look at Object-Oriented Programming as a whole — the paradigm that custom exception classes, and much of modern PHP, are built on.