Exception Handling in PHP

Exception handling is a very important feature in any programming language. It allow developers to manage program errors in very efficient way. It also allows developers to beautifully handle unexpected errors, prevent web application crashes and improve overall web aaplication experience. In this article, we will learn about Exception Handling in PHP with the help of examples.

What is Exception Handling?

Exception Handling is a method to findout and handle unwanted runtime errors in an application. Sometimes the application crashes due to these unwanted errors. However, the application crashes depends on the type of exceptions. It allow to display a proper error to users through defined alternative ways.

An exception is an object that indicates an issue or a condition in the programming. When any exception comes, PHP stops execting the normal flow of application and trying to find an appropriate exception handler.

Try, catch, and finally blocks are used in PHP to handle exceptions in an organized manner.

Try-Catch Block

It is generally used block by any developers.

Try block keeps the code that will execute and may throw some exception, if anything wrong.
Catch block handles the exception, if any error comes. It means we will display a meaningfull message to user, why this error came.

Syntax

try 
{
    if (function_exists('calculate_tax')) 
    {
        throw new Exception("Function not found");
    }
    
    echo "Function exists";
    
} 
catch (Exception $e) 
{
    // Handle the exception
    echo "Exception: " . $e->getMessage();
}

The Finally Block

The finally block will always execute whether an exception was thrown or not. It is always used with the try block. It is usefull for execute some important code of program like closing database connections, release resources etc.

Syntax

try 
{
    echo "Execute code...\n";
    
    throw new Exception("An error occurred");
    
} 
catch (Exception $e) 
{
    echo "Error: " . $e->getMessage() . "\n";
} 
finally 
{
    echo "This section will always execute.\n";
}

Throwing an Exception

The throw keyword is used to throw an exception. It transfer control to the closest catch block and stop execution of script. For example, When we divide the two numbers with each other and if the second number is zero, then we get "Division by zero" error.

function divide($a, $b) 
{
    if ($b == 0) 
    {
        throw new Exception("Division by zero is not allowed.");
    }
    return $a / $b;
}

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

Exception Hierarchy in PHP

Some built-in exception classes in PHP.

Exception: It is the Base class for all exceptions.
ErrorException: When we convert PHP related errors into an exceptions, then we used ErrorException.
LogicException: It always indicates logical errors such as invalid arguments.
RuntimeException: It always indicates runtime errors such as file not found.
PDOException: When we deal with PDO(PHP Data Object) Databases & any error comes related to database then we used PDOException.

Sometimes we need to show custom exceptions to user then we can create custom exception by extending the built-in Exception class.

class CustomException extends Exception 
{
    public function errorMessage() 
    {
        return "Custom Error: " . $this->getMessage();
    }
}

try 
{
    throw new CustomException("Something went wrong");
    
} 
catch (CustomException $e) 
{
    echo $e->errorMessage();
    
}

Best Practices for Exception Handling

We should catch a particular exception and display to user like PDOException or RuntimeException, instead of catch general exception.
We should always log or report exceptions instead of just suppressing them.
We should always use log files for an application or should use some monitoring tools for debugging.
We should display meaningfull messages of any exception.

Examples

Database Connection Handling

class Dbconnect
{
   
    // specify your own database credentials
    private $host = "localhost";
    private $db_name = "example";
    private $username = "root";
    private $password = "";
    public $conn;
   
    // get the database connection
    public function getConnection()
    {
   
        $this->conn = null;
   
        try
        {
            $this->conn = new PDO("mysql:host=" . $this->host . ";dbname=" . $this->db_name, $this->username, $this->password);
            
        }
        catch(PDOException $exception)
        {
            echo "Connection error: " . $exception->getMessage();
        }
   
        return $this->conn;
    }
}

API Request Handling

function fetchData($url) 
{
    $response = file_get_contents($url);
    
    if ($response === false) 
    {
        throw new Exception("Failed to fetch data from API");
    }
    return json_decode($response, true);
}

try 
{
    $data = fetchData("https://api.example.com/data");
    
} 
catch (Exception $e) 
{
    echo "API Error: " . $e->getMessage();
    
}

Conclusion

The ability to handle PHP exceptions is crucial for creating reliable, error-proof programs. You may create more dependable and maintainable programs by being aware of how exceptions operate, applying best practices, and managing exceptions effectively. An organized method of treating unforeseen problems politely is provided by exception handling, which can be used for database errors, API failures, or invalid user input.