PHP Error handling function _php instance

In PHP, the default error handling is simple. An error message is sent to the browser with the file name, line number, and message describing the error.

PHP Error Handling

Error handling is an important part of creating scripts and Web applications. If your code lacks error detection coding, the program looks unprofessional and opens the door to security risks.

This tutorial introduces some of the most important error detection methods in PHP.

We will explain the different error handling methods for you:

Simple "die ()" statement

Custom errors and error triggers

Error Reporting

Basic error handling: Using the Die () function

The first example shows a simple script that opens a text file:

<?php
$file =fopen ("Welcome.txt", "R");
? >

If the file does not exist, you will get an error similar to this:

Warning:fopen (Welcome.txt) [function.fopen]: failed to open stream:
No such file or directory in c:webfoldertest.php on line 2

To prevent the user from getting a similar error message, we detect whether the file exists before accessing the file:

<?php
if (!file_exists ("Welcome.txt"))
{
die ("File not Found");
}
else
{
$file =fopen ("Welcome.txt", "R");
}
? >

Now, if the file does not exist, you will get an error message like this:

File not found

The above code is more efficient than the previous code because it employs a simple error-handling mechanism that terminates the script after the error.

However, simply terminating the script is not always the right approach. Let's look at the alternate PHP functions for handling errors.

Creating custom Error Handlers

Creating a custom error handler is simple. We have simply created a private function that can be called when an error occurs in PHP.

The function must be capable of handling at least two parameters (Error level and error message), but can accept up to five parameters (optional: File, Line-number, and error context):

Grammar

Error_function (Error_level,error_message,error_file,error_line,error_context)

Parameters	Description
Error_level	Necessary. Sets the error reporting level for user-defined errors. Must be a number. See table below: Error reporting level.
Error_message	Necessary. Specify error messages for user-defined errors.
Error_file	Optional. The name of the file that specified the error occurred.
Error_line	Optional. The line number that sets the error to occur.
Error_context	Optional. Specify an array that contains each variable that was used when the error occurred and their values.

Error Reporting level

These error reporting levels are different types of errors handled by user-defined error handlers:

Now, let's create a function that handles the error:

function Customerror ($errno, $errstr)
{
echo "<b>Error:</b> [$errno] $errstr <br>";
echo "Ending Script";
Die ();
}

The code above is a simple error-handling function. When it is triggered, it gets the error level and error message. It then prints out the error level and message and terminates the script.

Now that we have created an error-handling function, we need to determine when the function is triggered.

value	Constants	Description
2	E_warning	Non-fatal run-time error. Script execution is not paused.
8	E_notice	Run-time notice. Occurs when the script discovers that there may be an error, but it may also occur when the script is running correctly.
256	E_user_error	Fatal user-generated error. This is similar to the e_error that programmers use PHP function Trigger_error () settings.
512	E_user_warning	A non-fatal user-generated warning. This is similar to the e_warning that programmers use PHP function Trigger_error () settings.
1024	E_user_notice	User-generated notifications. This is similar to the e_notice that programmers use PHP function Trigger_error () settings.
4096	E_recoverable_error	A fatal error that can be caught. Similar to E_error, but can be captured by user-defined handlers. (see Set_error_handler ())
8191	E_all	All errors and warnings. (In PHP 5.4, E_strict becomes part of the E_all)

To set up an error handler

The default error handler for PHP is a built-in error handler. We intend to transform the above function into the default error handler during the script run.

You can modify the error handler so that it applies only to certain errors, so that the script can handle different errors in different ways. In this case, however, we intend to use our custom error handlers for all errors:

Set_error_handler ("Customerror");

Since we want our custom function to handle all errors, Set_error_handler () only needs one argument and can add a second parameter to specify the error level.

Instance

Test this error handler by trying to output a variable that does not exist:

<?php
//error handler function
function Customerror ($errno, $errstr)
{
echo <b>Error:< /b> [$errno] $errstr ";
}
Set Error handler
Set_error_handler ("Customerror");
Trigger Error
Echo ($test);
? >

The output of the above code is as follows:

Error: [8] Undefined Variable:test

Trigger Error

In a script where the user enters data, it is useful to trigger an error when the user's input is invalid. In PHP, this task is done by the Trigger_error () function.

Instance

In this case, if the "test" variable is greater than "1", an error occurs:

<?php
$test =2;
if ($test >1)
{
trigger_error ("Value must be 1 or below");
>

The output of the above code is as follows:

Notice:value must be 1 or below
In c:webfoldertest.php on line 6

You can trigger an error anywhere in the script, and by adding the second parameter, you can specify the level of error that is triggered.

Possible types of errors:

E_user_error-Fatal user-generated run-time error. The error cannot be recovered. Script execution was interrupted.
E_user_warning-a Non-fatal user-generated run-time warning. Script execution is not interrupted.
E_user_notice-Default. User-generated Run-time notifications. Occurs when the script discovers that there may be an error, but it may also occur when the script is running correctly.

In this case, if the "test" variable is greater than "1", a e_user_warning error occurs. If e_user_warning occurs, we will use our custom error handlers and end the script:

<?php
//error handler function
function Customerror ($errno, $errstr)
{
echo <b>Error:< /b> [$errno] $errstr <br> ";
echo "Ending Script";
Die ();
}
Set Error handler
Set_error_handler ("Customerror", e_user_warning);
Trigger error
$test =2;
if ($test >1)
{
trigger_error ("Value must be 1 or below", e_user_warning);
>

The output of the above code is as follows:

Error: [i] Value must be 1 or below
Ending Script

Now that we've learned how to create our own error and how to trigger it, let's look at the error record.

Error logging

By default, PHP sends an error record to the server's recording system or file, based on the Error_log configuration in php.ini. By using the Error_log () function, you can send error records to the specified file or remote destination.

Sending an error message to yourself by e-mail is a good way to get a notification of a specified error.

Send an error message via e-mail

In the following example, if a specific error occurs, we will send an email with an error message and end the script:

<?php
//error handler function
function Customerror ($errno, $errstr)
{
echo <b>Error:< /b> [$errno] $errstr <br> ";
echo "Webmaster has been notified";
Error_log ("Error: [$errno] $errstr", 1,
"someone@example.com", "from:webmaster@example.com");
}
Set Error handler
Set_error_handler ("Customerror", e_user_warning);
Trigger error
$test =2;
if ($test >1)
{
trigger_error ("Value must be 1 or below", e_user_warning);
>

The output of the above code is as follows:

Error: [i] Value must be 1 or below
Webmaster has been notified

Messages received from the above code are shown below:

Error: [i] Value must be 1 or below

This method does not fit all the errors. General errors should be logged on the server by using the default PHP recording system.

The above content is a small series to introduce the PHP error handling function, I hope that the above help!