PHP Error Handling

PHP Error Handling: Comprehensive Guide for Developers

Introduction

Effective error handling is a critical part of building robust, secure, and user-friendly PHP applications. Without proper error management, your code can become difficult to debug, maintain, or secure. In this comprehensive tutorial, we will explore everything you need to know about PHP error handling, including best practices, built-in functions, custom error handlers, logging, and how to handle exceptions in PHP.

This guide includes high-ranking keywords such as php error handling, php try catch, php custom error handler, php display errors, and php exception handling.

What is Error Handling in PHP?

Error handling in PHP refers to the process of anticipating, detecting, and responding to errors or exceptions that occur during the execution of a script. PHP supports various types of errors, including warnings, notices, and fatal errors, and provides developers with tools to manage these issues effectively.

By implementing robust error handling techniques, developers can:

Prevent the application from crashing unexpectedly
Improve debugging and development workflows
Protect sensitive information from being exposed
Log errors for analysis and auditing
Provide better user experiences with custom error messages

Types of Errors in PHP

PHP categorizes errors into several types, each with different severity:

Parse Errors (Syntax Errors): Occur due to incorrect syntax and stop script execution.
Fatal Errors: Caused by calling undefined functions or accessing non-existent objects. They halt script execution.
Warnings: Non-fatal issues that don't stop script execution but indicate potential problems.
Notices: Informational messages about non-critical issues, such as accessing undefined variables.
Deprecated Warnings: Indicate features that are outdated and may be removed in future PHP versions.

Displaying Errors in PHP

To display errors during development, PHP provides the display_errors directive.

Enable Error Display in php.ini

display_errors = On
error_reporting = E_ALL

Or Enable Error Display at Runtime

ini_set('display_errors', 1);
ini_set('display_startup_errors', 1);
error_reporting(E_ALL);

Use this configuration only in development environments. In production, errors should be logged instead of displayed to users.

PHP Error Reporting Levels

The error_reporting() function is used to set the error reporting level.

Common Reporting Levels:

error_reporting(E_ALL); // Report all PHP errors
error_reporting(E_ERROR | E_WARNING); // Only fatal errors and warnings
error_reporting(0); // Turn off error reporting

Using try-catch in PHP for Exception Handling

Modern PHP supports object-oriented exception handling using try-catch blocks.

Basic Example:

try {
    if (!file_exists("data.txt")) {
        throw new Exception("File not found");
    }
    $content = file_get_contents("data.txt");
    echo $content;
} catch (Exception $e) {
    echo "Error: " . $e->getMessage();
}

Explanation:

try: Block of code to test for errors.
catch: Block of code to handle the exception.
throw: Used to trigger an exception manually.

PHP Exception Classes

PHP has a built-in Exception class that can be extended to create custom exception types.

Custom Exception Example:

class CustomException extends Exception {}

try {
    throw new CustomException("Custom error occurred");
} catch (CustomException $e) {
    echo "Caught custom exception: " . $e->getMessage();
}

Multiple Catch Blocks in PHP

PHP 7 introduced support for multiple catch blocks for different exception types.

try {
    // Code that may throw multiple exceptions
} catch (InvalidArgumentException $e) {
    echo "Invalid argument: " . $e->getMessage();
} catch (RuntimeException $e) {
    echo "Runtime error: " . $e->getMessage();
}

PHP finally Block

Use the finally block to execute code regardless of whether an exception was thrown or not.

try {
    echo "Trying code\n";
} catch (Exception $e) {
    echo "Caught error\n";
} finally {
    echo "This always runs\n";
}

Creating a Custom Error Handler in PHP

You can use the set_error_handler() function to define a custom way to handle errors.

Custom Error Handler Example:

function customError($errno, $errstr, $errfile, $errline) {
    echo "Error [$errno]: $errstr in $errfile on line $errline";
}

set_error_handler("customError");

// Trigger error
echo $undefinedVariable;

This overrides PHP's default error handling behavior and allows you to create more controlled responses.

Logging Errors to a File in PHP

Logging errors to a file is essential in production to keep track of issues without exposing them to users.

Configure Error Logging in php.ini

log_errors = On
error_log = /var/log/php_errors.log

Log Custom Error in PHP

error_log("Custom error message", 3, "/var/log/my_custom_error.log");

Converting Errors to Exceptions

You can convert standard PHP errors into exceptions using ErrorException.

set_error_handler(function ($errno, $errstr, $errfile, $errline) {
    throw new ErrorException($errstr, 0, $errno, $errfile, $errline);
});

try {
    echo $undefinedVariable;
} catch (ErrorException $e) {
    echo "Caught exception: " . $e->getMessage();
}

This technique is useful for unifying error and exception handling in your application.

Using trigger_error() to Create Custom Errors

PHP allows you to trigger custom errors using trigger_error().

Example:

$value = 0;
if ($value === 0) {
    trigger_error("Value cannot be zero", E_USER_WARNING);
}

Custom error types:

E_USER_NOTICE
E_USER_WARNING
E_USER_ERROR

Best Practices for PHP Error Handling

Display errors only in development - Prevents information leakage in production
Log errors to a secure location - Store logs outside of the web root and monitor them regularly
Use try-catch for critical operations - File I/O, database access, and third-party APIs
Create custom error pages - Display user-friendly error messages without revealing internal code
Never use @ to suppress errors - Silencing errors hides bugs and leads to unpredictable behavior
Handle exceptions globally - Use set_exception_handler() for fallback error control
Use structured logging formats - JSON or XML logs are easier to parse and integrate with tools

Global Exception Handler

Set a global exception handler for uncaught exceptions:

function handleUncaughtException($e) {
    error_log("Uncaught Exception: " . $e->getMessage());
    echo "An error occurred. Please try again later.";
}

set_exception_handler("handleUncaughtException");

// Trigger uncaught exception
throw new Exception("Something went wrong");

PHP Error Handling