PHP Error Reporting: Display Errors and E_ALL

To show PHP errors, put these lines at the top of your script: ini_set('display_errors', '1'); and error_reporting(E_ALL);. The first makes PHP print error messages, the second makes it report every kind of error, including warnings and deprecations.

<?php
ini_set('display_errors', '1');
ini_set('display_startup_errors', '1');
error_reporting(E_ALL);

With that in place, a mistake such as reading a variable that was never set prints a message with the file and line number instead of failing silently:

Warning: Undefined variable $total in /home/index.php on line 7

error_reporting() called with no argument returns the current setting as a number. Press Run to set a level and decode it back into names:

<?php
error_reporting(E_ALL & ~E_DEPRECATED);
$level = error_reporting();

echo "Current level: $level (E_ALL is " . E_ALL . ")\n";

foreach (get_defined_constants(true)['Core'] as $name => $value) {
    if (str_starts_with($name, 'E_') && $name !== 'E_ALL') {
        echo str_pad($name, 20), ($level & $value) ? "reported" : "off", "\n";
    }
}

Each error type is one bit, so E_ALL & ~E_DEPRECATED means "everything except deprecations". Change the first line to error_reporting(E_ERROR | E_WARNING); and run it again.

Display errors in php.ini

A setting in the script only applies once the script starts running. To show errors for every script, including parse errors, change php.ini (find it with php --ini):

; Development
display_errors = On
display_startup_errors = On
error_reporting = E_ALL

Restart Apache or PHP-FPM after editing. The php -S built-in server and the command line read the file on every start. On shared hosting without php.ini access, Apache with mod_php also accepts .htaccess lines:

php_flag display_errors on
php_value error_reporting -1

-1 sets every bit, which is the same as E_ALL.

The error levels

PHP 8.0 turned many old warnings into exceptions: dividing by zero with / and passing the wrong type to a built-in function now throw an Error subclass, the same way calling an undefined function has since PHP 7. You can catch all three:

<?php
$attempts = [
    fn() => 10 / 0,
    fn() => strlen([]),
    fn() => undefinedFunction(),
];

foreach ($attempts as $attempt) {
    try {
        $attempt();
    } catch (Throwable $e) {
        echo get_class($e), ": ", $e->getMessage(), "\n";
    }
}

Exceptions are covered in try and catch. Warnings, notices and deprecations still go through the error reporting system described here.

Log errors instead of displaying them

On a live site, visitors should never see error messages: they reveal paths, SQL and code. Write them to a log file instead:

; Production
display_errors = Off
log_errors = On
error_log = /var/log/php/app-errors.log
error_reporting = E_ALL

Keep error_reporting = E_ALL in production. Turning it down does not make the errors go away, it only stops you from hearing about them. Your own messages can go to the same log with error_log():

<?php
error_log("Payment failed for order 1042");

Then watch the file while you test: tail -f /var/log/php/app-errors.log.

Turn warnings into exceptions with set_error_handler

set_error_handler replaces PHP's default handling of warnings, notices and deprecations with your own function. A common pattern converts every one into an ErrorException, so a forgotten array key stops the code like any other exception and can be caught:

<?php
set_error_handler(function (int $severity, string $message, string $file, int $line): bool {
    throw new ErrorException($message, 0, $severity, $file, $line);
});

$prices = ['bread' => 4.5, 'milk' => 1.2];

try {
    echo "Bread costs {$prices['bread']}\n";
    echo "Cheese costs {$prices['cheese']}\n";
} catch (ErrorException $e) {
    echo "Caught: ", $e->getMessage(), " on line ", $e->getLine(), "\n";
}

restore_error_handler();

The handler receives the error level as its first argument, so it can treat levels differently. This one only logs deprecations and turns everything else into an exception:

<?php
set_error_handler(function (int $severity, string $message): bool {
    if ($severity === E_DEPRECATED || $severity === E_USER_DEPRECATED) {
        echo "[log] deprecated: $message\n";
        return true; // handled, PHP does nothing more
    }
    throw new ErrorException($message, 0, $severity);
});

trigger_error("oldFunction() is deprecated, use newFunction()", E_USER_DEPRECATED);

try {
    trigger_error("Config value 'timeout' is missing", E_USER_WARNING);
} catch (ErrorException $e) {
    echo "Exception: ", $e->getMessage(), "\n";
}

Fatal errors and parse errors never reach the handler, because the script cannot continue after them. To record those, register a shutdown function that reads error_get_last().

Read the last error with error_get_last

Some functions return false and report the reason only as a warning, for example file_get_contents on a missing file. error_get_last() returns that warning as an array, which is useful when you want to show your own message:

<?php
$content = @file_get_contents('missing-config.json');

if ($content === false) {
    $error = error_get_last();
    echo "Could not read the file.\n";
    echo "Type: ", $error['type'] === E_WARNING ? 'E_WARNING' : $error['type'], "\n";
    echo "Message: ", $error['message'], "\n";
}

The @ operator in front of the call suppresses the message for that one expression. Use it sparingly and only when you check the result right after, as here; an @ on its own only hides bugs.

Common mistake: errors are on, but the page is still blank

If you added ini_set('display_errors', '1') and still see a white page, the error is probably a parse error. PHP parses the whole file before running the first line, so a missing ; or } stops everything before ini_set runs. Check the file from the terminal, which always prints the message:

php -l index.php

Errors parsing index.php
PHP Parse error:  syntax error, unexpected token "," in index.php on line 2

The line number points at where PHP gave up, which is often the line after the real mistake. Fix it, run php -l again until it says No syntax errors detected, then reload the page.