PHP Exceptions
PHP Exceptions
An exception is an unexcepted outcome of a program, which can be handled by the program itself. Basically, an exception disrupts the normal flow of the program. But it is different from an error because an exception can be handled, whereas an error cannot be handled by the program itself.
An exception is an object that describes an error or unexpected behaviour of a PHP script. Exceptions are thrown by many PHP functions and classes. User defined functions and classes can also throw exceptions.
Exceptions are a good way to stop a function when it comes across data that it cannot use.PHP provides a powerful mechanism, exception handling. It allows you to handle runtime errors such as IOException, SQLException, ClassNotFoundException, and more. A most popular example of exception handling is - divide by zero exception, which is an arithmetic exception.
Throwing an Exception
The throw statement allows a user defined function or method to throw an exception. When an exception is thrown, the code following it will not be executed.
If an exception is not caught, a fatal error will occur with an "Uncaught Exception" message. An uncaught exception will always result in script termination. So if you want the script to continue executing beyond the point where the exception occurred, you must have have at least one corresponding catch block for each try block.
Lets try to throw an exception without catching it:
This example shows how to encode an associative array into a JSON object:
`
<?php
function divide($dividend, $divisor) {
if($divisor == 0) {
throw new Exception("Division by zero");
}
return $dividend / $divisor;
}
echo divide(5, 0);
?>
The try...catch Statement
To avoid the error from the example above, we can use the try...catch statement to catch exceptions and continue the process.
`
try {
code that can throw exceptions
} catch(Exception $e) {
code that runs when an exception is caught
}
The catch block indicates what type of exception should be caught and the name of the variable which can be used to access the exception. In the example above, the type of exception is Exception and the variable name is $e.
`
<?php
function divide($dividend, $divisor) {
if($divisor == 0) {
throw new Exception("Division by zero");
}
return $dividend / $divisor;
}
try {
echo divide(5, 0);
} catch(Exception $e) {
echo "Unable to divide.";
}
?>
The try...catch...finally Statement
The try...catch...finally statement can be used to catch exceptions. Code in the finally block will always run regardless of whether an exception was caught. If finally is present, the catch block is optional.
try {
code that can throw exceptions
} catch(Exception $e) {
code that runs when an exception is caught
} finally {
code that always runs regardless of whether an exception was caught
}
Show a message when an exception is thrown and then indicate that the process has ended:
`
<?php
function divide($dividend, $divisor) {
if($divisor == 0) {
throw new Exception("Division by zero");
}
return $dividend / $divisor;
}
try {
echo divide(5, 0);
} catch(Exception $e) {
echo "Unable to divide. ";
} finally {
echo "Process complete.";
}
?>
<?php
function divide($dividend, $divisor) {
if($divisor == 0) {
throw new Exception("Division by zero");
}
return $dividend / $divisor;
}
try {
echo divide(5, 0);
} catch(Exception $e) {
echo "Unable to divide. ";
} finally {
echo "Process complete.";
}
?>
<?php
function divide($dividend, $divisor) {
if($divisor == 0) {
throw new Exception("Division by zero");
}
return $dividend / $divisor;
}
try {
echo divide(5, 0);
} finally {
echo "Process complete.";
}
?>
The Exception Object
The Exception Object contains information about the error or unexpected behaviour that the function encountered. its Syntax is:
new Exception(message, code, previous)
`Parameter Values
`| Parameter | Description |
|---|---|
| message | Optional. A string describing why the exception was thrown |
| code | Optional. An integer that can be used used to easily distinguish this exception from others of the same type |
| previous | Optional. If this exception was thrown in a catch block of another exception, it is recommended to pass that exception into this parameter |
Methods
When catching an exception, the following table shows some of the methods that can be used to get information about the exception:
`| Methods | Description |
|---|---|
| getMessage() | Returns a string describing why the exception was thrown |
| getPrevious() | If this exception was triggered by another one, this method returns the previous exception. If not, then it returns null |
| getCode() | Returns the exception code |
| getFile() | Returns the full path of the file in which the exception was thrown |
| getLine() | Returns the line number of the line of code which threw the exception |
<?php
function divide($dividend, $divisor) {
if($divisor == 0) {
throw new Exception("Division by zero", 1);
}
return $dividend / $divisor;
}
try {
echo divide(5, 0);
} catch(Exception $ex) {
$code = $ex->getCode();
$message = $ex->getMessage();
$file = $ex->getFile();
$line = $ex->getLine();
echo "Exception thrown in $file on line $line: [Code $code]
$message";
}
?>
