Chapter 13 · Going Deeper

Exceptions & Errors

Things go wrong: the database is down, the user typed "banana" as their age, a file is missing. Beginner code either crashes with an ugly white screen or hides problems with die(). Professional code handles trouble gracefully — with exceptions.

Throwing an exception

When your code detects an impossible situation, it throws an exception object — stopping normal flow instantly:

<?php
class BankAccount {
    private float $balance = 0;

    public function withdraw(float $amount): void {
        if ($amount <= 0) {
            throw new InvalidArgumentException("Amount must be positive.");
        }
        if ($amount > $this->balance) {
            throw new Exception("Insufficient funds: balance is K$this->balance.");
        }
        $this->balance -= $amount;
    }
}

Compare with the old chapters where withdraw() just echoed "Insufficient funds". That was weak: the calling code had no way to know the withdrawal failed. A thrown exception is unmissable — ignore it and the program stops.

Catching with try / catch

$account = new BankAccount();

try {
    $account->withdraw(500);
    echo "Withdrawal successful!";       // this line is skipped if a throw happens above it
} catch (Exception $e) {
    echo "Sorry: " . $e->getMessage();
}

echo "<br>The program continues normally.";

Read the flow like a story:

1. try { ... } — "attempt this risky block."
2. The moment a throw happens inside, PHP abandons the rest of the try block and jumps to the matching catch.
3. catch (Exception $e) — the exception object lands in $e. $e->getMessage() gives the human-readable reason.
4. After the catch block, life continues — no crash.

Catching different problems differently

Exceptions are objects, so they have classes — and you can catch each type with its own response. PHP checks the catch blocks top to bottom and uses the first that matches:

try {
    $account->withdraw(-50);
} catch (InvalidArgumentException $e) {
    echo "Input problem: " . $e->getMessage();     // this one matches
} catch (Exception $e) {
    echo "General problem: " . $e->getMessage();   // the safety net for everything else
}

Custom exceptions — alarms with names

Making your own exception type is delightfully easy: extend Exception. Even an empty class is valuable, because its name tells the story:

class InsufficientFundsException extends Exception {}
class StudentNotFoundException extends Exception {}

function findStudent(int $id): string {
    $register = [1 => "Chanda", 2 => "Mutinta"];
    if (!isset($register[$id])) {
        throw new StudentNotFoundException("No student with ID $id.");
    }
    return $register[$id];
}

try {
    echo findStudent(99);
} catch (StudentNotFoundException $e) {
    echo "Lookup failed: " . $e->getMessage();
}

finally — the cleanup crew

A finally block runs no matter what — success or failure. Use it for cleanup that must always happen (closing files, releasing resources):

try {
    echo "Opening report file...<br>";
    throw new Exception("Printer on fire!");
} catch (Exception $e) {
    echo "Caught: " . $e->getMessage() . "<br>";
} finally {
    echo "Closing report file. (This always runs.)";
}

Where to catch? A practical map

• Deep code (classes, models): throw freely. A class should refuse bad situations loudly — it should never echo error text or die(), because it can't know whether it's running inside a webpage, an API or a test.
• Surface code (the page the user visits): catch, then show a friendly message and log the technical details. Users should see "Something went wrong, please try again" — never a raw stack trace.

Keep that split in mind — our final project follows it exactly, and Chapter 15 uses exceptions to handle database failures.

<?php
function divide(float $a, float $b): float {
    if ($b == 0) {
        throw new InvalidArgumentException("Cannot divide by zero.");
    }
    return $a / $b;
}

try {
    echo divide(10, 2) . "<br>";   // 5
    echo divide(5, 0) . "<br>";    // throws — line below never runs
    echo "You will never see this.";
} catch (InvalidArgumentException $e) {
    echo "Error: " . $e->getMessage();
}