PHP error handling is an essential aspect of writing robust and reliable PHP applications. In PHP 8, several improvements have been made to error handling, including the introduction of new error types and improvements to existing features. In this tutorial, we’ll cover the fundamentals of PHP error handling and discuss error handlers, both built-in and custom.

Table of Contents

1. Error Types in PHP 8
2. Basic Error Handling
3. Custom Error Handlers
4. Exception Handling
5. Error Suppression
6. Logging Errors
7. Conclusion

1. Error Types in PHP 8

PHP 8 introduces several new error types and categorizes errors into two main categories: Fatal Errors and Non-Fatal Errors.

• Fatal Errors: These errors are severe and usually result in the termination of the script. Examples include undefined function or class, syntax errors, and maximum execution time exceeded.
• Non-Fatal Errors: These errors are less severe and can be handled gracefully without terminating the script. Examples include warnings and notices.

2. Basic Error Handling

PHP provides built-in functions for basic error handling, such as error_reporting, ini_set, and set_error_handler.

• error_reporting: This function sets the level of error reporting. For example, error_reporting(E_ALL) will display all errors, while error_reporting(0) will disable error reporting.
• ini_set: It can be used to change PHP configuration settings at runtime. For error handling, you can use ini_set('display_errors', '1') to display errors on the screen.
• set_error_handler: This function allows you to set a custom error handler function to handle non-fatal errors.

Here’s an example of setting up basic error handling:

// Enable error reporting and display errors
ini_set('display_errors', '1');
error_reporting(E_ALL);

// Custom error handler
function customErrorHandler($errno, $errstr, $errfile, $errline) {
    echo "Error [$errno]: $errstr in $errfile on line $errline";
}

set_error_handler('customErrorHandler');

3. Custom Error Handlers

Custom error handlers can be defined to handle non-fatal errors in a more user-friendly way. These handlers are defined using the set_error_handler function, as shown in the previous example.

Custom error handlers receive four parameters:

• $errno: The level of the error.
• $errstr: The error message.
• $errfile: The file where the error occurred.
• $errline: The line number where the error occurred.

You can define your custom logic to handle errors, such as logging, displaying user-friendly messages, or sending error notifications.

4. Exception Handling

Exception handling is a more advanced form of error handling in PHP that allows you to deal with both fatal and non-fatal errors uniformly. Exceptions are thrown when an error occurs and can be caught and handled using try, catch, and finally blocks.

try {
    // Code that may throw an exception
    $result = 10 / 0; // Division by zero
} catch (Throwable $e) {
    // Handle the exception
    echo "Caught exception: " . $e->getMessage();
} finally {
    // Cleanup code (optional)
}

Using exceptions is recommended for handling errors that can be anticipated and handled gracefully.

5. Error Suppression

In some cases, you may want to suppress errors for a specific section of code, such as when checking for the existence of a file. You can use the @ symbol before an expression to suppress errors.

$file = @file_get_contents('nonexistent-file.txt');

if ($file === false) {
    // Handle the error
    echo "Failed to read file.";
}

However, it’s generally not recommended to use error suppression excessively, as it can lead to debugging challenges.

6. Logging Errors

Logging is an essential part of error handling, as it helps in diagnosing issues in production environments. You can use PHP’s built-in logging functions or third-party logging libraries to log errors.

// Logging errors to a file
ini_set('log_errors', '1');
ini_set('error_log', 'error.log');

7. Conclusion

Effective error handling is crucial for developing robust PHP applications. In PHP 8, you have various options for handling errors, from basic error reporting to custom error handlers and exception handling. Choose the approach that best suits your application’s requirements and always strive to make your code more robust and user-friendly by handling errors gracefully.