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.

<?php
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).

 

Syntax

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.

error_message

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

error_file

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

error_line

Optional—Lists the line number where the error happened.

error_context

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.

.E_ERROR

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

E_WARNING

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

E PARSE

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

E_NOTICE

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

E_CORE_ERROR

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

E_CORE_WARNING

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

E_USER_ERROR

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

E_USER_WARNING

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

E_USER_NOTICE

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

 E_STRICT

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.

 E_RECOVERABLE_ERROR

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

E_ALL

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:

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

die();
}
?>

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).

Example

<?php
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

<?php
function exception_handler($exception) {
echo \”Uncaught exception: \” , $exception->getMessage(), \”\\n\”;
}

set_exception_handler(\’exception_handler\’);
throw new Exception(\’Uncaught Exception\’);

echo \”Not Executed\”;
?>

Related Posts
50+ PHP Interview Questions and Answers 2023

1. Differentiate between static and dynamic websites. Static Website The content cannot be modified after the script is executed The Read more

All We Need to Know About PHP Ecommerce Development

  Many e-commerce sites let you search for products, show them off, and sell them online. The flood of money Read more

PHP Custom Web Development: How It Can Be Used, What Its Pros and Cons Are,

PHP is a scripting language that runs on the server. It uses server resources to process outputs. It is a Read more

PHP Tutorial

Hypertext Preprocessor (PHP) is a programming language that lets web developers make dynamic content that works with databases. PHP is Read more

Introduction of PHP

PHP started out as a small open source project that grew as more and more people found out how useful Read more

Syntax Overview of PHP

This chapter will show you some of PHP\'s very basic syntax, which is very important for building a strong PHP Read more

Environment Setup in PHP

To develop and run PHP on your computer, you need to instal three important parts. Web server PHP can almost Read more

Variable Types in PHP

Using a variable is the main way to store information in the middle of a PHP program. Here are the Read more

Scroll to Top