Exception Handling in PHP
Exception Handling in PHP is the process followed by the programmer to handle exceptions which are thrown during the program execution. Exceptions are raised when some line of code breaks and does not execute as expected. These exceptions if not caught properly will cause our application to stop which will not be a good experience for end users who are not aware of the underlying details of the application. A good programmer always write his code considering exception handling in mind.
Difference between Errors and Exceptions in PHP
- Errors in PHP are those exceptions which cannot be handled and leads to halting of the application.
- Errors are generally raised by the environment in which the application is running. For ex. if the memory runs out of space.
- Errors can not be handled using try catch block.
Handling Exceptions using Try Catch Block
Exceptions in PHP are handled using try catch block in which the code where there is a possibility of the exception being raised is put into try block and the exception handling code is placed in catch block which if followed by try block.
For example:
// code before try block try { // code to be executed // Something unexpected happens the the control of execution will jump to catch part // once the control is transferred to catch part the rest of the code in try block will not be executed } catch (Exception $e) { // exception will be handled here // $e->getMessage() contains the error message // Exception logging can be used with the method name in which the exception has occured along with the excetion detail } // code after try block
Inside the catch block an exception object is passed which consists of the information about the exception.
Throwing an exception using throw keyword
We can also explicitly throw exceptions using the throw keyword. For example we can validate the data entered by the user and can throw exception is the data is not valid.
For example:
<?php try { // store the file path in a variable $file_path = "config.php"; if (!file_exists($file_path)) { throw new Exception("file not found."); } } catch (Exception $e) { echo $e->getMessage(); die(); } ?>
In the above example we are checking whether a config.php file exists or not if it does not exist we are throwing an exception manually which will be caught in the catch block where we are showing the error message and also stopped the execution of the application.
Try block can not stand alone it must be followed by at least one catch block. Catch blocks can also be more than one if we want to handle multiple exception types where more specific exceptions are always kept at the top and more general exception classes are kept at the bottom.
Exceptions if they are not handled in the same function in which they are thrown will be propagated further to the calling code where they can be handled.
For example:
<?php //function with an exception function checkNumber($num) { if($num>=10) { //throw an exception throw new Exception("Value must be less than 10"); } return true; } //trigger an exception in a "try" block try { checkNumber(4); //If the exception throws, below text will not be display echo 'If you see this text, the passed value is less than 10'; } //catch exception catch (Exception $e) { echo 'Exception Message: ' .$e->getMessage(); } ?>
In the above code exception is being thrown from the function but the try catch block in not inside the function rather the function call is enclosed inside try catch block.
The Finally block
This block of code is used to execute code that need to executed always irrespective of the exception whether it has occurred or not.
For example:
try { } catch (Exception $e) { } finally { // code, it'll always be executed }
Finally block is generally used to clean up the resources being used during the program like open db connections or open files etc.
Custom Exceptions in PHP
We can create our own exception classes in PHP if our requirement is not satisfied with inbuilt classes available in PHP. In order to create our own exception classes we need to create a new class that derives from the base Exception class.
<?php //Custom Exception classes that derives from the exception class class DivideByZeroException extends Exception { } class DivideByNegativeNoException extends Exception { } function checkdivisor($dividend, $divisor){ try { if ($divisor == 0) { //throw object of the custom exception class throw new DivideByZeroException; } else if ($divisor < 0) { throw new DivideByNegativeNoException; } else { $result = $dividend / $divisor; echo "Result of division = $result </br>"; } } catch (DivideByZeroException $dze) { echo "Divide by Zero Exception! </br>"; } catch (DivideByNegativeNoException $dnne) { echo "Divide by Negative Number Exception </br>"; } catch (Exception $ex) { // if the exception is not caught in the above catch blocks than it will come here echo "Unknown Exception"; } } checkdivisor(17, 3);// no exception will be thrown checkdivisor(45, -6); // Divide by negative number exception will be thrown checkdivisor(30, 0); // Divide by zero exception will be thrown ?>
In the above code we are creating two custom classes that derive from the base exception class. One will be used to throw exception if the divisor is zero and other will be used to throw exception if the divisor is negative.
Function checkdivisor() is called three times to see the different error messages based on the divisor being passed to it either positive, negative or zero.