Error & Exception Handling PHP

Error & Exception Handling PHP is the process of figuring out what went wrong with your programme and fixing it. If you don’t deal with errors the right way, it could lead to a lot of unexpected things.

Handling errors in PHP is very easy.

Using the function die()

Before going any further with your PHP programme, you should check for all possible error conditions and take the right steps when they happen.

Try the following example with and without the /tmp/dummy.txt file.

if(!file_exists(“/tmp/dummy.txt”)) {
die(“404 File not found”);
}else {
$file = fopen(“/tmp/dummy.txt”,”r”);
print “File Opend sucessfully”;
// Test code here.

So, you can write code that works well. Using the above method, you can stop your programme when it makes a mistake and show a more helpful error message.

Custom Error Handling Function Definition

You can make your own error-handling function. PHP gives you a framework for defining how to handle errors.

This function must be able to handle at least two parameters (error level and error message), but it can take up to five (optionally: file, line-number, and the error context).



error function(error level,error message, error file,error line,error context);

error level

Required: Sets the error report level for the user-defined error. Must be a number value.


Required: Gives the error message for the user-defined error.


Optional: Gives the name of the file in which the error happened.


Optional—Lists the line number where the error happened.


Optional: Gives a list of all the variables and their values that were being used when the error happened.

Possible Error levels

The user-defined error handler can be used for each of these different types of errors. Using the | operator, these values can be used together.


Fatal run-time errors. The script is no longer being run.


Non-fatal run-time errors. The script is not stopped from running.


Compile-time parse errors. Only the parser should be able to make parse errors.


Run-time notices. Something that might be an error, but could also happen when a script is run normally, was found by the script.


Fatal errors that happen when PHP starts up for the first time.


Non-fatal run-time errors. This happens when PHP starts up for the first time.


Fatal user-generated error. This is like when a programmer uses the PHP function trigger error to set an E ERROR ()


User-made warning that is not fatal. This is like when a programmer uses the PHP function trigger error to set an E WARNING ()


Notice made by the user. This is like when a programmer uses the PHP function trigger error to set an E NOTICE ()


Run-time notices. Allow PHP to suggest changes to your code that will make it work best with other programmes and work in the future.


Catchable fatal error. This is the same as an E ERROR, but a user-defined handle can catch it (see also set error handler()).


All errors and warnings except level E STRICT (E STRICT will be part of E ALL starting with PHP 6.0).

All of the above error levels can be set using the following PHP built-in library function, where level can be any of the values listed in the table above.

int error reporting ([int $level])


Here’s how you can make one error-handling function:

function handleError($errno, $errstr,$error_file,$error_line) {
echo “<b>Error:</b> [$errno] $errstr – $error_file:$error_line”;
echo “<br />”;
echo “Terminating PHP Script”;


Exceptions Handling

Like other programming languages, PHP 5 has an exception model. Exceptions are important because they give you more control over how you handle errors.

Let’s talk about their new keyword, which has to do with exceptions.

Try:  A “try” block should be around a function that throws an exception. If the exception doesn’t happen, the code will keep going like usual. If the exception does happen, however, an exception is “thrown.”

Throw: This is how you make an exception happen. There must be at least one “catch” for every “throw.”

Catch: A “catch” block gets an exception and makes an object with the information about the exception.

When an exception is thrown, the code that comes after the statement is not run. Instead, PHP tries to find the first catch block that matches. If an exception isn’t caught, PHP will give a Fatal Error with the message “Uncaught Exception…

  • In PHP, you can throw and catch (or “catch”) an exception. Code can be put in a try block.
  • Each try must have at least one catch block, and different types of exceptions can be caught in different catch blocks.
  • In a catch block, exceptions can be thrown (or re-thrown).


try {
$error = ‘Always throw this error’;
throw new Exception($error);

// Code following an exception is not executed.
echo ‘Never executed’;
}catch (Exception $e) {
echo ‘Caught exception: ‘, $e->getMessage(), “\n”;

// Continue execution
echo ‘Test Error’;

In the example above, the $e->getMessage function is used to get the error message. The Exception class also has the following functions that can be used.

  • getMessage() = error message
  • getCode() = exception code
  • getFile() − source filename
  • getLine() − source line
  • getTrace() gives you an array of n backtraces ()
  • getTraceAsString() returns a string of formatted trace

Making a custom handler for exceptions

You can set up your own user-defined exception handler function by calling the following function.

string set_exception_handler ($exception handler is a callback)

This is the name of the function that will be called when an uncaught exception happens. This function  must be defined before set_exception_handler

function exception_handler($exception) {
echo “Uncaught exception: ” , $exception->getMessage(), “\n”;

throw new Exception(‘Uncaught Exception’);

echo “Not Executed”;

People also search

Leave a Comment

Scroll to Top