Introduction to Error Handling in PHP

Table of Contents

• Introduction to Error Handling
• Types of Errors in PHP
  • Syntax Errors
  • Runtime Errors
  • Logic Errors
• Error Reporting in PHP
  • error_reporting()
  • ini_set()
  • Displaying Errors
• Handling Errors with try-catch Block
  • Syntax of try-catch
  • Throwing Exceptions
• Custom Error Handling
  • Setting Custom Error Handlers
  • Example of Custom Error Handler
• Working with Error Logs
• Best Practices in Error Handling
• Practical Example: Error Handling in a Web Application
• Summary

Introduction to Error Handling

Error handling is a crucial aspect of software development that ensures the proper functioning of an application, even in the face of unexpected issues. In PHP, error handling allows you to detect, manage, and respond to runtime issues effectively, preventing your application from crashing or behaving unpredictably. Proper error handling makes your code more robust, secure, and user-friendly.

This module will introduce you to the core concepts of error handling in PHP, including different types of errors, how to report and manage errors, and how to create custom error handlers. We’ll also explore how to work with error logs to help you troubleshoot and monitor your application.

Types of Errors in PHP

There are three main types of errors in PHP: Syntax errors, Runtime errors, and Logic errors.

1. Syntax Errors

Syntax errors occur when PHP encounters incorrect code structure, such as missing semicolons, parentheses, or braces. These errors prevent the script from running and are typically detected before the script executes.

Example of a syntax error:

<?php
echo "Hello World"
?>

The missing semicolon (;) at the end of the echo statement will cause a syntax error.

2. Runtime Errors

Runtime errors occur during the execution of a PHP script. These errors often happen when there is a problem with the logic of the code, such as attempting to use an undefined variable or trying to divide by zero.

Example of a runtime error:

<?php
$result = 10 / 0;
?>

This will generate a division by zero error.

3. Logic Errors

Logic errors are not detected by PHP and do not produce any error messages, but they can cause the program to behave incorrectly. These errors happen when the code runs without generating a syntax or runtime error but does not produce the expected result.

Example of a logic error:

<?php
$sum = 5 + 10;
echo $sum; // Should be 15, but you mistakenly expected it to be 20.
?>

Though the code runs without any errors, the result is not what was intended due to a logic mistake in the developer’s expectations.

Error Reporting in PHP

PHP provides built-in functions and configuration settings to control error reporting. By enabling error reporting, you can display or log errors during the development process, which helps in debugging.

1. error_reporting()

The error_reporting() function allows you to set the level of error reporting in PHP. It determines which types of errors should be displayed or logged.

error_reporting(E_ALL); // Report all errors

Common error reporting levels include:

• E_ALL: Reports all errors and warnings.
• E_ERROR: Reports fatal runtime errors.
• E_WARNING: Reports non-fatal runtime errors.
• E_NOTICE: Reports undefined variables or other minor issues.

2. ini_set()

You can use the ini_set() function to configure the display of errors. This function is used to modify PHP configuration settings during runtime.

ini_set('display_errors', 1); // Display errors on the screen

To hide errors on the screen, set the display_errors directive to 0:

ini_set('display_errors', 0); // Hide errors from the screen

3. Displaying Errors

While developing, you’ll want to display errors to make debugging easier. In production, however, it’s a good practice to log errors instead of displaying them, as revealing error details could be a security risk.

To enable error display:

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

To disable error display:

ini_set('display_errors', 0);
error_reporting(0);

Handling Errors with try-catch Block

PHP introduced exception handling with try-catch blocks in version 5. Exceptions allow you to handle errors in a more controlled and organized manner. In contrast to traditional error reporting, exceptions allow you to throw and catch errors within specific sections of your code.

Syntax of try-catch

A try-catch block consists of two main parts:

• try block: Contains the code that might throw an exception.
• catch block: Contains the code that handles the exception if one is thrown.

Example:

<?php
try {
    $dividend = 10;
    $divisor = 0;
    if ($divisor == 0) {
        throw new Exception("Division by zero error.");
    }
    $result = $dividend / $divisor;
    echo $result;
} catch (Exception $e) {
    echo "Error: " . $e->getMessage();
}
?>

In the example above, the throw keyword is used to manually throw an exception when attempting to divide by zero. The catch block catches the exception and handles it by displaying a custom error message.

Throwing Exceptions

You can also throw your own exceptions in PHP using the throw keyword. This is useful when you want to trigger specific error conditions manually.

throw new Exception("Custom error message.");

You can also pass custom error codes or additional details when throwing exceptions.

Custom Error Handling

PHP allows you to set custom error handlers that replace the default PHP error handling behavior. This is useful when you want to handle errors in a specific way or log them to a file.

Setting a Custom Error Handler

Use the set_error_handler() function to define a custom error handler.

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

// Set custom error handler
set_error_handler("customError");

This will display custom error messages whenever a PHP error occurs.

Custom Error Handler Example

function handle_error($errno, $errstr, $errfile, $errline) {
    $logMessage = "Error [$errno]: $errstr in $errfile on line $errline";
    error_log($logMessage, 3, "error_log.txt"); // Log error to file
    echo "An error occurred. Please try again later.";
}

// Set the custom error handler
set_error_handler("handle_error");

In this example, all errors will be logged to a file named error_log.txt.

Working with Error Logs

Instead of displaying errors on the screen, it’s recommended to log errors in a file, especially in production environments. PHP provides the error_log() function to log errors to a file.

Example: Logging Errors

error_log("This is a custom error message.", 3, "/var/log/php_errors.log");

You can also configure PHP to log errors automatically by modifying the php.ini file:

log_errors = On
error_log = /path/to/error_log

Logging errors to a file helps in monitoring issues without exposing them to the end-users.

Best Practices in Error Handling

• Use Exception Handling for Critical Errors: Exception handling provides better control over errors and helps in maintaining clean code.
• Display Errors in Development, Log in Production: During development, display errors to make debugging easier. In production, log errors to a file and avoid displaying them to users.
• Validate User Input: Ensure user input is validated before processing to prevent errors from occurring.
• Use Custom Error Handlers: Create custom error handlers to handle errors consistently across your application.
• Log Errors: Always log errors in a file to keep track of issues in production.

Practical Example: Error Handling in a Web Application

Here’s a simple example of handling errors in a web application where a user inputs data.

<?php
function validate_input($data) {
    if (empty($data)) {
        throw new Exception("Input cannot be empty.");
    }
    return $data;
}

try {
    $input = validate_input($_POST['user_input']);
    echo "User input: " . $input;
} catch (Exception $e) {
    echo "Error: " . $e->getMessage();
}
?>

In this example, an exception is thrown if the input is empty, and the error is caught and displayed to the user.

Summary

In this module, we’ve covered the core aspects of error handling in PHP, including the types of errors, error reporting mechanisms, and how to handle errors using try-catch blocks. We also explored custom error handling and error logging techniques, which are essential for creating stable, reliable PHP applications.

By understanding and implementing proper error handling techniques, you can build applications that are both more secure and more user-friendly.