Exception Handling

🎭 PHP Exception Handling: Your Safety Net for Code Chaos!

The Magic Story: The Circus Performer’s Safety Net

Imagine you’re at a circus watching acrobats fly through the air. They do amazing flips and jumps high above the ground! 🎪

But wait—what if they fall?

That’s why there’s a safety net below them! If anything goes wrong, the net catches them safely, and the show can continue!

PHP Exception Handling works exactly like that safety net!

• Your code tries something risky (like the acrobat doing a flip)
• If something goes wrong, an exception is thrown (the acrobat falls)
• The catch block is your safety net that catches the problem
• The show (your program) can keep going!

🎯 What You’ll Learn

graph TD
    A["Throwable Interface"] --> B["try Block"]
    B --> C["throw Statement"]
    C --> D["catch Block"]
    D --> E["finally Block"]
    E --> F["Exception Class"]
    F --> G["Custom Exceptions"]
    G --> H["Multiple catch Blocks"]

1️⃣ The Throwable Interface: The Boss of All Errors

Think of Throwable as the big boss of all problems in PHP. Every error or exception must follow the boss’s rules!

What does the boss control?

• Exceptions (mistakes we can catch)
• Errors (serious problems like running out of memory)

// Throwable is like the
// family tree of all problems
//
// Throwable (The Boss)
//    ├── Error (Serious stuff)
//    └── Exception (Catchable stuff)

Simple Example:

function handleProblem(Throwable $t) {
    echo "Problem: " . $t->getMessage();
}

try {
    throw new Exception("Oops!");
} catch (Throwable $t) {
    handleProblem($t);
}
// Output: Problem: Oops!

Why it matters: The Throwable interface lets you catch BOTH errors and exceptions with one catch!

2️⃣ The try Block: “Let Me Try This Risky Thing!”

The try block is like saying: “Hey PHP, I’m about to do something that might fail. Watch me!”

try {
    // Risky code goes here
    // Like the acrobat doing a flip!
    $result = riskyOperation();
}

Real Life Example:

try {
    $file = fopen("secret.txt", "r");
    // What if the file doesn't exist?
    // That's why we use try!
}

Rules for try:

• Always needs at least one catch or finally
• Put your “maybe dangerous” code inside
• PHP watches everything inside for problems

3️⃣ The throw Statement: “Houston, We Have a Problem!”

When something goes wrong, you throw an exception. It’s like yelling “HELP!” 🚨

throw new Exception("Something bad!");

Think of it like this:

• A waiter drops a plate 🍽️
• They yell “BROKEN PLATE!”
• Someone catches the problem

Example:

function divide($a, $b) {
    if ($b == 0) {
        // Can't divide by zero!
        throw new Exception(
            "Cannot divide by zero!"
        );
    }
    return $a / $b;
}

// Later in code:
try {
    echo divide(10, 0); // Throws!
} catch (Exception $e) {
    echo $e->getMessage();
}
// Output: Cannot divide by zero!

4️⃣ The catch Block: Your Safety Net!

The catch block catches thrown exceptions—just like a safety net catches falling acrobats!

try {
    // Risky flip
    throw new Exception("Fell!");
} catch (Exception $e) {
    // Safety net catches it!
    echo "Caught: " . $e->getMessage();
}
// Output: Caught: Fell!

What can you do in catch?

• Show a friendly error message
• Log the problem
• Try a backup plan
• Clean up any mess

The $e variable:

catch (Exception $e) {
    $e->getMessage();  // What went wrong
    $e->getCode();     // Error number
    $e->getFile();     // Which file
    $e->getLine();     // Which line
}

5️⃣ The finally Block: “I Run No Matter What!”

The finally block is like the cleanup crew. It runs whether things went well OR badly!

try {
    echo "Trying...\n";
    throw new Exception("Oops!");
} catch (Exception $e) {
    echo "Caught!\n";
} finally {
    echo "Cleaning up!\n";
}
// Output:
// Trying...
// Caught!
// Cleaning up!

Why use finally?

• Close files you opened
• Disconnect from databases
• Release resources
• Guaranteed cleanup!

Even with return:

function test() {
    try {
        return "from try";
    } finally {
        echo "finally runs!";
    }
}
echo test();
// Output: finally runs!from try

6️⃣ The Exception Class: Meet the Star Player

The Exception class is PHP’s built-in way to describe problems.

$e = new Exception(
    "message",  // What happened
    123         // Error code
);

What’s inside an Exception?

Example:

try {
    throw new Exception("Oops!", 42);
} catch (Exception $e) {
    echo "Message: " . $e->getMessage();
    echo "\nCode: " . $e->getCode();
}
// Output:
// Message: Oops!
// Code: 42

7️⃣ Custom Exceptions: Build Your Own!

Sometimes you need special exception types. Make your own! 🏗️

class AgeException extends Exception {
    // Custom exception for age problems
}

class NameException extends Exception {
    // Custom exception for name problems
}

Why make custom exceptions?

• Different problems need different handling
• Better organized code
• Easier to find and fix bugs

Full Example:

class TooYoungException extends Exception {
    private $age;

    public function __construct($age) {
        $this->age = $age;
        parent::__construct(
            "Too young! Got: $age"
        );
    }

    public function getAge() {
        return $this->age;
    }
}

function checkAge($age) {
    if ($age < 18) {
        throw new TooYoungException($age);
    }
    return "Welcome!";
}

try {
    echo checkAge(15);
} catch (TooYoungException $e) {
    echo $e->getMessage();
    echo "\nAge was: " . $e->getAge();
}
// Output:
// Too young! Got: 15
// Age was: 15

8️⃣ Multiple catch Blocks: Different Nets for Different Falls

Different problems need different solutions! Use multiple catch blocks.

graph TD
    A["try block"] --> B{Exception?}
    B -->|FileException| C["Handle file error"]
    B -->|DatabaseException| D["Handle DB error"]
    B -->|Any Exception| E["General handler"]

Example:

class FileError extends Exception {}
class DBError extends Exception {}

try {
    // Some risky code
    throw new DBError("No connection");

} catch (FileError $e) {
    echo "File problem: " . $e->getMessage();

} catch (DBError $e) {
    echo "Database problem: " . $e->getMessage();

} catch (Exception $e) {
    echo "Other problem: " . $e->getMessage();
}
// Output: Database problem: No connection

Order matters!

// ✅ RIGHT - specific first
catch (FileError $e) { }
catch (Exception $e) { }

// ❌ WRONG - general first catches all!
catch (Exception $e) { }  // Catches everything
catch (FileError $e) { }  // Never reached!

🎭 The Complete Picture

Here’s everything working together:

class InvalidAgeException
    extends Exception {}

function registerUser($name, $age) {
    // Check age
    if ($age < 13) {
        throw new InvalidAgeException(
            "Must be 13 or older"
        );
    }
    // Check name
    if (empty($name)) {
        throw new Exception(
            "Name required"
        );
    }
    return "Welcome, $name!";
}

try {
    echo registerUser("", 10);

} catch (InvalidAgeException $e) {
    echo "Age error: " . $e->getMessage();

} catch (Exception $e) {
    echo "Error: " . $e->getMessage();

} finally {
    echo "\n...Registration attempted.";
}

// Output:
// Age error: Must be 13 or older
// ...Registration attempted.

🚀 Quick Summary

🎉 You Did It!

You now understand PHP Exception Handling! Remember:

1. try = “I’ll try this risky thing”
2. throw = “Something went wrong!”
3. catch = “I’ll handle that problem”
4. finally = “I’ll clean up no matter what”

Your code now has a safety net! Go write fearless PHP! 🎪✨