error_reporting - PHP code example

The PHP Function Error_Reporting

The php function error_reporting is one of the most important built-in functions in PHP. It helps developers to display errors in their scripts and in the web application. It has a few parameters and returns the current error reporting level. The levels include error, notice, and warning.

Errors are the most severe type of error messages. These are caused when a program has a logical flaw that prevents it from functioning properly. Examples of these errors include syntax errors such as missing a semicolon or brackets or calling an undefined function. These types of errors cause the program to stop executing.

Notices are less severe than errors, but they can still impact the correct behavior of a program. These errors may occur due to missing or invalid arguments, or if the code attempts to open an undefined file or function. Notices will not halt the execution of a program, but they are still worth reporting to developers.

Warnings are more serious than notices and indicate that there is an issue with the code that should be addressed. These issues may not be fatal, but they need to be fixed as soon as possible. Examples of these errors include undefined variables or attempting to use deprecated functions.

The php function error_reporting allows developers to filter which errors can be displayed. This is done by using the character to indicate “not/no” and the & symbol to indicate “true for all”. For example, passing the error_reporting function with E_ALL will display all PHP errors.

error_reporting example

namespace Symfony\Component\ErrorHandler;

/** * Registers all the debug tools. * * @author Fabien Potencier <fabien@symfony.com> */
class Debug
{
    public static function enable(): ErrorHandler
    {
        error_reporting(-1);

        if (!\in_array(\PHP_SAPI, ['cli', 'phpdbg'], true)) {
            ini_set('display_errors', 0);
        } elseif (!filter_var(\ini_get('log_errors'), \FILTER_VALIDATE_BOOL) || \ini_get('error_log')) {
            // CLI - display errors only if they're not already logged to STDERR             ini_set('display_errors', 1);
        }

        @ini_set('zend.assertions', 1);
        ini_set('assert.active', 1);
        ini_set('assert.exception', 1);

    public static function writeFile($_filepath, $_contents, Smarty $smarty)
    {
        if (empty($_contents)) {
            return false;
        }
        $_error_reporting = error_reporting();
        error_reporting($_error_reporting & ~E_NOTICE & ~E_WARNING);
        if ($smarty->_file_perms !== null) {
            $old_umask = umask(0);
        }

        $_dirpath = dirname($_filepath);
        // if subdirs, create dir structure         if ($_dirpath !== '.' && !self::ensureDirectoryExists($_dirpath, $smarty->_dir_perms)) {
            error_reporting($_error_reporting);
            throw new SmartyException("unable to create directory {$_dirpath}");
        }

'length' => strlen($file),
                );
            }
            if (!strncmp($errfile, $dir['file'], $dir['length'])) {
                $_is_muted_directory = true;
                break;
            }
        }

        // pass to next error handler if this error did not occur inside SMARTY_DIR         // or the error was within smarty but masked to be ignored         if (!$_is_muted_directory || ($errno && $errno & error_reporting())) {
            if (Smarty::$_previous_error_handler) {
                return call_user_func(Smarty::$_previous_error_handler, $errno, $errstr, $errfile, $errline);
            } else {
                return false;
            }
        }
    }

    /** * Enable error handler to mute expected messages * * @return void */

use CodeIgniter\Config\DotEnv;
use Config\Autoload;
use Config\Modules;
use Config\Paths;
use Config\Services;

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

// Make sure it recognizes that we're testing. $_SERVER['CI_ENVIRONMENT'] = 'testing';
define('ENVIRONMENT', 'testing');
defined('CI_DEBUG') || define('CI_DEBUG', true);

// Often these constants are pre-defined, but query the current directory structure as a fallback defined('HOMEPATH') || define('HOMEPATH', realpath(rtrim(getcwd(), '\\/ ')) . DIRECTORY_SEPARATOR);
$source = is_dir(HOMEPATH . 'app')
?

if ( function_exists( 'error_reporting' ) ) {
    /* * Initialize error reporting to a known set of levels. * * This will be adapted in wp_debug_mode() located in wp-includes/load.php based on WP_DEBUG. * @see https://www.php.net/manual/en/errorfunc.constants.php List of known error levels. */
    error_reporting( E_CORE_ERROR | E_CORE_WARNING | E_COMPILE_ERROR | E_ERROR | E_WARNING | E_PARSE | E_USER_ERROR | E_USER_WARNING | E_RECOVERABLE_ERROR );
}

/* * If wp-config.php exists in the WordPress root, or if it exists in the root and wp-settings.php * doesn't, load wp-config.php. The secondary check for wp-settings.php has the added benefit * of avoiding cases where the current directory is a nested installation, e.g. / is WordPress(a) * and /blog/ is WordPress(b). * * If neither set of conditions is true, initiate loading the setup process. */
if ( file_exists( ABSPATH . 'wp-config.php' ) ) {

        return $this->isFinder ? ($this->classLoader[0]->findFile($class) ?: null) : null;
    }

    /** * Loads the given class or interface. * * @throws \RuntimeException */
    public function loadClass(string $class): void
    {
        $e = error_reporting(error_reporting() | \E_PARSE | \E_ERROR | \E_CORE_ERROR | \E_COMPILE_ERROR);

        try {
            if ($this->isFinder && !isset($this->loaded[$class])) {
                $this->loaded[$class] = true;
                if (!$file = $this->classLoader[0]->findFile($class) ?: '') {
                    // no-op                 } elseif (\function_exists('opcache_is_script_cached') && @opcache_is_script_cached($file)) {
                    include $file;

                    return;
                } elseif (false === include $file) {

    public function errorHandler(int $severity, string $message, ?string $file = null, ?int $line = null)
    {
        if ($this->isDeprecationError($severity)) {
            if (! $this->config->logDeprecations || (bool) env('CODEIGNITER_SCREAM_DEPRECATIONS')) {
                throw new ErrorException($message, 0, $severity, $file, $line);
            }

            return $this->handleDeprecationError($message, $file, $line);
        }

        if (error_reporting() & $severity) {
            throw new ErrorException($message, 0, $severity, $file, $line);
        }

        return false; // return false to propagate the error to PHP standard error handler     }

    /** * Checks to see if any errors have happened during shutdown that * need to be caught and handle them. * * @codeCoverageIgnore * * @return void * @phpstan-return never|void */

        $defaultCommands = parent::getDefaultCommands();

        $defaultCommands[] = new UpdateCommand();

        return $defaultCommands;
    }

    private function registerErrorHandler()
    {
        set_error_handler(function D$errno, $errstr, $errfile, $errline) {
            // error was suppressed with the @-operator             if (error_reporting() === 0 || $errno === E_USER_DEPRECATED) {
                return false;
            }

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

<?php
/* |-------------------------------------------------------------------------- | ERROR DISPLAY |-------------------------------------------------------------------------- | In development, we want to show as many errors as possible to help | make sure they don't make it to production. And save us hours of | painful debugging. */
error_reporting(-1);
ini_set('display_errors', '1');

/* |-------------------------------------------------------------------------- | DEBUG BACKTRACES |-------------------------------------------------------------------------- | If true, this constant will tell the error screens to display debug | backtraces along with the other error information. If you would | prefer to not see this, set this value to false. */
defined('SHOW_DEBUG_BACKTRACE') || define('SHOW_DEBUG_BACKTRACE', true);

if (PHP_VERSION_ID < 70400) {
    header('Content-type: text/html; charset=utf-8', true, 503);
    echo '<h2>Fehler</h2>';
    echo 'Auf Ihrem Server läuft PHP version ' . PHP_VERSION . ', Shopware 5 benötigt mindestens PHP 7.4.0.';
    echo '<h2>Error</h2>';
    echo 'Your server is running PHP version ' . PHP_VERSION . ' but Shopware 5 requires at least PHP 7.4.0.';
    exit;
}

require_once __DIR__ . '/../common/autoload.php';

error_reporting(E_ERROR | E_WARNING | E_PARSE | E_NOTICE);
ini_set('display_errors', 1);
date_default_timezone_set('UTC');
set_time_limit(0);

use Shopware\Recovery\Install\Console\Application;
use Symfony\Component\Console\Input\ArgvInput;

if (PHP_SAPI === 'cli') {
    $input = new ArgvInput();
    $env = $input->getParameterOption(['--env', '-e'], 'production');

namespace Symfony\Component\Runtime\Internal;

/** * @author Nicolas Grekas <p@tchwork.com> * * @internal */
class BasicErrorHandler
{
    public static function register(bool $debug): void
    {
        error_reporting(-1);

        if (!\in_array(\PHP_SAPI, ['cli', 'phpdbg'], true)) {
            ini_set('display_errors', $debug);
        } elseif (!filter_var(\ini_get('log_errors'), \FILTER_VALIDATE_BOOL) || \ini_get('error_log')) {
            // CLI - display errors only if they're not already logged to STDERR             ini_set('display_errors', 1);
        }

        if (0 <= \ini_get('zend.assertions')) {
            ini_set('zend.assertions', 1);
            ini_set('assert.active', $debug);

if (0 !== $status) {
        bailout($genrb.' failed.');
    }

    if (!preg_match('/ICU version ([\d\.]+)/', implode('', $output), $matches)) {
        return null;
    }

    return $matches[1];
}

error_reporting(\E_ALL);

set_error_handler(function Dint $type, string $msg, string $file, int $line) {
    throw new \ErrorException($msg, 0, $type, $file, $line);
});

set_exception_handler(function DThrowable $exception) {
    echo "\n";

    $cause = $exception;
    $root = true;

$connect_timeout = max( $timeout, 1 );

        // Store error number.         $connection_error = null;

        // Store error string.         $connection_error_str = null;

        if ( ! WP_DEBUG ) {
            // In the event that the SSL connection fails, silence the many PHP warnings.             if ( $secure_transport ) {
                $error_reporting = error_reporting( 0 );
            }

            if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) ) {
                // phpcs:ignore WordPress.PHP.NoSilencedErrors.Discouraged                 $handle = @stream_socket_client(
                    'tcp://' . $proxy->host() . ':' . $proxy->port(),
                    $connection_error,
                    $connection_error_str,
                    $connect_timeout,
                    STREAM_CLIENT_CONNECT,
                    $context
                );

// Please update when phpunit needs to be reinstalled with fresh deps: // Cache-Id: 2021-02-04 11:00 UTC
if ('cli' !== \PHP_SAPI && 'phpdbg' !== \PHP_SAPI) {
    throw new Exception('This script must be run from the command line.');
}

error_reporting(-1);

global $argv, $argc;
$argv = $_SERVER['argv'] ?? [];
$argc = $_SERVER['argc'] ?? 0;
$getEnvVar = function D$name, $default = false) use ($argv) {
    if (false !== $value = getenv($name)) {
        return $value;
    }

    static $phpunitConfig = null;
    if (null === $phpunitConfig) {

        do_action( 'customize_render_partials_before', $this, $partials );

        set_error_handler( array( $this, 'handle_error' ), error_reporting() );

        $contents = array();

        foreach ( $partials as $partial_id => $container_contexts ) {
            $this->current_partial_id = $partial_id;

            if ( ! is_array( $container_contexts ) ) {
                wp_send_json_error( 'malformed_container_contexts' );
            }

            $partial = $this->get_partial( $partial_id );