Предопределенные константы

Перечисленные ниже константы всегда доступны как часть ядра PHP.

Замечание: Данные имена констант можно использовать в файле php.ini но не вне PHP, как например в файле httpd.conf, где вместо них необходимо использовать значения их битовых масок.

Ошибки и протоколирование
Значение Константа Описание Примечание
1 E_ERROR (integer) Фатальные ошибки времени выполнения. Это неустранимые средствами самого скрипта ошибки, такие как ошибка распределения памяти и т.п. Выполнение скрипта в таком случае прекращается.  
2 E_WARNING (integer) Предупреждения времени выполнения (не фатальные ошибки). Выполнение скрипта в таком случае не прекращается.  
4 E_PARSE (integer) Ошибки на этапе компиляции. Должны генерироваться только парсером.  
8 E_NOTICE (integer) Уведомления времени выполнения. Указывают на то, что во время выполнения скрипта произошло что-то, что может указывать на ошибку, хотя это может происходить и при обычном выполнении программы.  
16 E_CORE_ERROR (integer) Фатальные ошибки, которые происходят во время запуска РНР. Такие ошибки схожи с E_ERROR, за исключением того, что они генерируются ядром PHP.  
32 E_CORE_WARNING (integer) Предупреждения (не фатальные ошибки), которые происходят во время начального запуска РНР. Такие предупреждения схожи с E_WARNING, за исключением того, что они генерируются ядром PHP.  
64 E_COMPILE_ERROR (integer) Фатальные ошибки на этапе компиляции. Такие ошибки схожи с E_ERROR, за исключением того, что они генерируются скриптовым движком Zend.  
128 E_COMPILE_WARNING (integer) Предупреждения на этапе компиляции (не фатальные ошибки). Такие предупреждения схожи с E_WARNING, за исключением того, что они генерируются скриптовым движком Zend.  
256 E_USER_ERROR (integer) Сообщения об ошибках сгенерированные пользователем. Такие ошибки схожи с E_ERROR, за исключением того, что они генерируются в коде скрипта средствами функции PHP trigger_error().  
512 E_USER_WARNING (integer) Предупреждения сгенерированные пользователем. Такие предупреждения схожи с E_WARNING, за исключением того, что они генерируются в коде скрипта средствами функции PHP trigger_error().  
1024 E_USER_NOTICE (integer) Уведомления сгенерированные пользователем. Такие уведомления схожи с E_NOTICE, за исключением того, что они генерируются в коде скрипта, средствами функции PHP trigger_error().  
2048 E_STRICT (integer) Включаются для того, чтобы PHP предлагал изменения в коде, которые обеспечат лучшее взаимодействие и совместимость кода. Начиная с PHP 5, но не включены в E_ALL вплоть до PHP 5.4.0
4096 E_RECOVERABLE_ERROR (integer) Фатальные ошибки с возможностью обработки. Такие ошибки указывают, что, вероятно, возникла опасная ситуация, но при этом, скриптовый движок остается в стабильном состоянии. Если такая ошибка не обрабатывается функцией, определенной пользователем для обработки ошибок (см. set_error_handler()), выполнение приложения прерывается, как происходит при ошибках E_ERROR. Начиная с PHP 5.2.0
8192 E_DEPRECATED (integer) Уведомления времени выполнения об использовании устаревших конструкций. Включаются для того, чтобы получать предупреждения о коде, который не будет работать в следующих версиях PHP. Начиная с PHP 5.3.0
16384 E_USER_DEPRECATED (integer) Уведомления времени выполнения об использовании устаревших конструкций, сгенерированные пользователем. Такие уведомления схожи с E_DEPRECATED за исключением того, что они генерируются в коде скрипта, с помощью функции PHP trigger_error(). Начиная с PHP 5.3.0
32767 E_ALL (integer) Все поддерживаемые ошибки и предупреждения, за исключением ошибок E_STRICT до PHP 5.4.0. 32767 в PHP 5.4.x, 30719 в PHP 5.3.x, 6143 в PHP 5.2.x, 2047 ранее

Представленные выше значения (как числовые, так и символьные) используются для задания битовой маски, определяющей об ошибках какого типа будет даваться отчет. Вы можете использовать побитовые операторы, чтобы совмещать эти значения для указания определенных типов ошибок. Стоит отметить, что в php.ini допустимы только следующие операторы: '|', '~', '!', '^' и '&'.

Коментарии

Автор:
Well, technically -1 will show all errors which includes any new ones included by PHP. My guess is that E_ALL will always include new error constants so I usually prefer:

<?php
error_reporting
(E_ALL E_STRICT);
?>

Reason being: With a quick glance anyone can tell you what errors are reported. -1 might be a bit more cryptic to newer programmers.
2010-07-15 06:26:25
http://php5.kiev.ua/manual/ru/errorfunc.constants.html
-1 is also semantically meaningless as a bit field, and only works in 2s-complement numeric representations.  On a 1s-complement system -1 would not set E_ERROR.  On a sign-magnitude system -1 would set nothing at all! (see e.g. http://en.wikipedia.org/wiki/Ones%27_complement)

If you want to set all bits, ~0 is the correct way to do it.

But setting undefined bits could result in undefined behaviour and that means *absolutely anything* could happen :-)
2011-04-16 07:15:20
http://php5.kiev.ua/manual/ru/errorfunc.constants.html
function FriendlyErrorType($type)
    {
        switch($type)
            {
            case E_ERROR: // 1 //
                return 'E_ERROR';
            case E_WARNING: // 2 //
                return 'E_WARNING';
            case E_PARSE: // 4 //
                return 'E_PARSE';
            case E_NOTICE: // 8 //
                return 'E_NOTICE';
            case E_CORE_ERROR: // 16 //
                return 'E_CORE_ERROR';
            case E_CORE_WARNING: // 32 //
                return 'E_CORE_WARNING';
            case E_CORE_ERROR: // 64 //
                return 'E_COMPILE_ERROR';
            case E_CORE_WARNING: // 128 //
                return 'E_COMPILE_WARNING';
            case E_USER_ERROR: // 256 //
                return 'E_USER_ERROR';
            case E_USER_WARNING: // 512 //
                return 'E_USER_WARNING';
            case E_USER_NOTICE: // 1024 //
                return 'E_USER_NOTICE';
            case E_STRICT: // 2048 //
                return 'E_STRICT';
            case E_RECOVERABLE_ERROR: // 4096 //
                return 'E_RECOVERABLE_ERROR';
            case E_DEPRECATED: // 8192 //
                return 'E_DEPRECATED';
            case E_USER_DEPRECATED: // 16384 //
                return 'E_USER_DEPRECATED';
            }
        return $type;
    }
2012-03-16 11:35:12
http://php5.kiev.ua/manual/ru/errorfunc.constants.html
[Editor's note: fixed E_COMPILE_* cases that incorrectly returned E_CORE_* strings. Thanks josiebgoode.]

The following code expands on Vlad's code to show all the flags that are set.  if not set, a blank line shows.

<?php
$errLvl 
error_reporting();
for (
$i 0$i 15$i++ ) {
    print 
FriendlyErrorType($errLvl pow(2$i)) . "<br>\\n"
}

function 
FriendlyErrorType($type)
{
    switch(
$type)
    {
        case 
E_ERROR// 1 //
           
return 'E_ERROR';
        case 
E_WARNING// 2 //
           
return 'E_WARNING';
        case 
E_PARSE// 4 //
           
return 'E_PARSE';
        case 
E_NOTICE// 8 //
           
return 'E_NOTICE';
        case 
E_CORE_ERROR// 16 //
           
return 'E_CORE_ERROR';
        case 
E_CORE_WARNING// 32 //
           
return 'E_CORE_WARNING';
        case 
E_COMPILE_ERROR// 64 //
           
return 'E_COMPILE_ERROR';
        case 
E_COMPILE_WARNING// 128 //
           
return 'E_COMPILE_WARNING';
        case 
E_USER_ERROR// 256 //
           
return 'E_USER_ERROR';
        case 
E_USER_WARNING// 512 //
           
return 'E_USER_WARNING';
        case 
E_USER_NOTICE// 1024 //
           
return 'E_USER_NOTICE';
        case 
E_STRICT// 2048 //
           
return 'E_STRICT';
        case 
E_RECOVERABLE_ERROR// 4096 //
           
return 'E_RECOVERABLE_ERROR';
        case 
E_DEPRECATED// 8192 //
           
return 'E_DEPRECATED';
        case 
E_USER_DEPRECATED// 16384 //
           
return 'E_USER_DEPRECATED';
    }
    return 
"";
}
?>
2012-07-16 21:25:27
http://php5.kiev.ua/manual/ru/errorfunc.constants.html
Автор:
this would give you all the reported exception list of your configuration.

<?php
function FriendlyErrorType($type)

   
$return ="";
    if(
$type E_ERROR// 1 //
       
$return.='& E_ERROR ';
    if(
$type E_WARNING// 2 //
       
$return.='& E_WARNING ';
    if(
$type E_PARSE// 4 //
       
$return.='& E_PARSE ';
    if(
$type E_NOTICE// 8 //
       
$return.='& E_NOTICE ';
    if(
$type E_CORE_ERROR// 16 //
       
$return.='& E_CORE_ERROR ';
    if(
$type E_CORE_WARNING// 32 //
       
$return.='& E_CORE_WARNING ';
    if(
$type E_COMPILE_ERROR// 64 //
       
$return.='& E_COMPILE_ERROR ';
    if(
$type E_COMPILE_WARNING// 128 //
       
$return.='& E_COMPILE_WARNING ';
    if(
$type E_USER_ERROR// 256 //
       
$return.='& E_USER_ERROR ';
    if(
$type E_USER_WARNING// 512 //
       
$return.='& E_USER_WARNING ';
    if(
$type E_USER_NOTICE// 1024 //
       
$return.='& E_USER_NOTICE ';
    if(
$type E_STRICT// 2048 //
       
$return.='& E_STRICT ';
    if(
$type E_RECOVERABLE_ERROR// 4096 //
       
$return.='& E_RECOVERABLE_ERROR ';
    if(
$type E_DEPRECATED// 8192 //
       
$return.='& E_DEPRECATED ';
    if(
$type E_USER_DEPRECATED// 16384 //
       
$return.='& E_USER_DEPRECATED ';
    return 
substr($return,2);

echo 
"error_reporting = " FriendlyErrorType(ini_get('error_reporting')) .";<br>";
?>
2012-09-02 10:31:50
http://php5.kiev.ua/manual/ru/errorfunc.constants.html
How about this?  Unlike the examples below, it will show all the bits that are set, AND handle any bits defined in the future (at least not silently hide them)...

    $strErrorType = "";
    $bit = 1;
    $tmpErrNo = $errNo;
    while ($tmpErrNo) {
        if ($tmpErrNo & $bit) {
            if ($strErrorType != "")
                $strErrorType .= " | ";
            switch ($bit) {
            case E_USER_WARNING:
                $strErrorType .= "E_USER_WARNING"; break;
            case E_USER_NOTICE:
                $strErrorType .= "E_USER_NOTICE"; break;
            case E_WARNING:
                $strErrorType .= "E_WARNING"; break;
            case E_CORE_WARNING:
                $strErrorType .= "E_CORE_WARNING"; break;
            case E_COMPILE_WARNING:
                $strErrorType .= "E_COMPILE_WARNING"; break;
            case E_NOTICE:
                $strErrorType .= "E_NOTICE"; break;
            case E_ERROR:
                $strErrorType .= "E_ERROR"; break;
            case E_PARSE:
                $strErrorType .= "E_PARSE"; break;
            case E_CORE_ERROR:
                $strErrorType .= "E_CORE_ERROR"; break;
            case E_COMPILE_ERROR:
                $strErrorType .= "E_COMPILE_ERROR"; break;
            case E_USER_ERROR:
                $strErrorType .= "E_USER_ERROR"; break;   
            default:
                $strErrorType .= "(unknown error bit $bit)"; break;
            }
        }
        $tmpErrNo &= ~$bit;
        $bit <<= 1;
    }
2014-08-29 10:06:55
http://php5.kiev.ua/manual/ru/errorfunc.constants.html
I use this code to help mimic the default error handler, the only difference is that the levels end up being all caps, which I don't care to fix. You could also get rid of the underscores, but again, I don't care :P
Until php starts adding constants starting with E_ that have values overlapping with other E_ constants, this seems to be the shortest way of converting error code integers to strings understandable by meat bags. It will also work with new types, so that's nice.
<?php
function friendly_error_type($type) {
    static 
$levels=null;
    if (
$levels===null) {
       
$levels=[];
        foreach (
get_defined_constants() as $key=>$value) {
            if (
strpos($key,'E_')!==0) {continue;}
           
$levels[$value]=substr($key,2);
        }
    }
    return (isset(
$levels[$type]) ? $levels[$type] : "Error #{$type}");
}
echo 
friendly_error_type(1); #ERROR
echo friendly_error_type(2); #WARNING
echo friendly_error_type(3); #Error #3
?>
Tested on 5.6.12 and 7.0.3 (The first was by accident, didn't realize I was sshed into production :3)
2016-03-15 18:21:08
http://php5.kiev.ua/manual/ru/errorfunc.constants.html
I saw that Chris seems to think that errors might be combined in some cases, I don't know of any cases, but his code is overly verbose, inefficient, and doesn't take into account future E_ constants. Here's my version of handling multiple errors (which probably wont ever happen) using my other code as a base. The only real difference is that this doesn't bother to split out undefined bits, which is pretty much useless and would get rather messy if you have more than a few bits set above 2**14 (0 to 14 have an associated error).

<?php
function friendly_error_type($type) {
    static 
$levels=null;
    if (
$levels===null) {
       
$levels=[];
        foreach (
get_defined_constants() as $key=>$value) {
            if (
strpos($key,'E_')!==0) {continue;}
           
$levels[$value]=substr($key,2);
        }
    }
   
$out=[];
    foreach (
$levels as $int=>$string) {
        if (
$int&$type) {$out[]=$string;}
       
$type&=~$int;
    }
    if (
$type) {$out[]="Error Remainder [{$type}]";}
    return 
implode(' & ',$out);
}
echo 
friendly_error_type(E_ERROR|E_USER_DEPRECATED); //ERROR & USER_DEPRECATED
echo friendly_error_type(2**20-1); //ERROR & RECOVERABLE_ERROR & WARNING & PARSE & NOTICE & STRICT & DEPRECATED & CORE_ERROR & CORE_WARNING & COMPILE_ERROR & COMPILE_WARNING & USER_ERROR & USER_WARNING & USER_NOTICE & USER_DEPRECATED & Error Remainder [1015808]
?>
2016-03-17 16:22:52
http://php5.kiev.ua/manual/ru/errorfunc.constants.html
Автор:
My version!
For long list function returns for example "E_ALL without E_DEPRECATED "

function errorLevel()
{
    $levels = array(
        'E_ERROR',
        'E_WARNING',
        'E_PARSE',
        'E_NOTICE',
        'E_CORE_ERROR',
        'E_CORE_WARNING',
        'E_COMPILE_ERROR',
        'E_COMPILE_WARNING',
        'E_USER_ERROR',
        'E_USER_WARNING',
        'E_USER_NOTICE',
        'E_STRICT',
        'E_RECOVERABLE_ERROR',
        'E_DEPRECATED',
        'E_USER_DEPRECATED',
        'E_ALL'
    );
    $excluded = $included = array();
    $errLvl = error_reporting();
    foreach ($levels as $lvl) {
        $val = constant($lvl);
        if ($errLvl & $val) {
            $included []= $lvl;
        } else {
                $excluded []= $lvl;
        }
    }
    if (count($excluded) > count($included)) {
        echo '<br />Consist: '.implode(',', $included);
    } else {
        echo '<br />Consist: E_ALL without '.implode(',', $excluded);
    }
}
2016-06-15 10:38:35
http://php5.kiev.ua/manual/ru/errorfunc.constants.html
Автор:
if you want to bring this list back to the categories error/warning/notice/all

<?php

$error_level   
'warning';      //  Allowed values: error/warning/notice/all

$error_error   = (int)                  E_ERROR E_USER_ERROR E_CORE_ERROR E_COMPILE_ERROR E_RECOVERABLE_ERROR E_PARSE;
$error_warning = (int) $error_error   E_WARNING E_USER_WARNING E_CORE_WARNING E_COMPILE_WARNING;
$error_notice  = (int) $error_warning E_NOTICE E_USER_NOTICE E_DEPRECATED E_USER_DEPRECATED;
$error_all     = (int) $error_notice  E_STRICT;

error_reporting ($GLOBALS["error_$error_level"]);

?>
2016-06-22 11:00:53
http://php5.kiev.ua/manual/ru/errorfunc.constants.html
As for me, the best way to get error name by int value is that. And it's works fine for me ;)
<?php

array_flip
(array_slice(get_defined_constants(true)['Core'], 115true))[$type];

//the same in readable form
array_flip(
   
array_slice(
       
get_defined_constants(true)['Core'],
       
1,
       
15,
       
true
   
)
)[
$type]

?>
2016-08-13 21:58:34
http://php5.kiev.ua/manual/ru/errorfunc.constants.html
Notes posted above limited to current errors level as on 26th Aug 2016, following snippet will work even on introduction of new error level

$errLvl = error_reporting(); 
for ( $i = 1; $i < E_ALL;  $i*=2 )

    print FriendlyErrorType($errLvl & $i) . "<br>\n"; 
}

function FriendlyErrorType($type) 

    switch($type) 
    { 
        case E_ERROR: // 1 // 
            return 'E_ERROR'; 
        case E_WARNING: // 2 // 
            return 'E_WARNING'; 
        case E_PARSE: // 4 // 
            return 'E_PARSE'; 
        case E_NOTICE: // 8 // 
            return 'E_NOTICE'; 
        case E_CORE_ERROR: // 16 // 
            return 'E_CORE_ERROR'; 
        case E_CORE_WARNING: // 32 // 
            return 'E_CORE_WARNING'; 
        case E_COMPILE_ERROR: // 64 // 
            return 'E_COMPILE_ERROR'; 
        case E_COMPILE_WARNING: // 128 // 
            return 'E_COMPILE_WARNING'; 
        case E_USER_ERROR: // 256 // 
            return 'E_USER_ERROR'; 
        case E_USER_WARNING: // 512 // 
            return 'E_USER_WARNING'; 
        case E_USER_NOTICE: // 1024 // 
            return 'E_USER_NOTICE'; 
        case E_STRICT: // 2048 // 
            return 'E_STRICT'; 
        case E_RECOVERABLE_ERROR: // 4096 // 
            return 'E_RECOVERABLE_ERROR'; 
        case E_DEPRECATED: // 8192 // 
            return 'E_DEPRECATED'; 
        case E_USER_DEPRECATED: // 16384 // 
            return 'E_USER_DEPRECATED'; 
    } 
    return ""; 
}
2016-08-26 18:47:02
http://php5.kiev.ua/manual/ru/errorfunc.constants.html
The bitmask values relative to the Constant E_ALL is 30719, in case of PHP 5.6.x
2017-03-23 18:12:46
http://php5.kiev.ua/manual/ru/errorfunc.constants.html
A simplified way of writting a function to return a (non-optimal) representation of the error code as a bitwise string:

<?php
   
function readable_error_type($error_code)
    {
       
$constants = array();
        foreach(
get_defined_constants() as $key => $value)
        {
            if(
strpos($key'E_') === && ($value <= $error_code) && ($value $error_code))
            {
               
$constants[] = $key;
            }
        }

        return 
implode(' | '$constants);
    }
?>

This only works for values above 0.
2017-04-20 19:58:12
http://php5.kiev.ua/manual/ru/errorfunc.constants.html
An other way to get all PHP errors  that are set to be reported. This code will even work, when additional error types are added in future.

<?php
$pot 
0;
foreach (
array_reverse(str_split(decbin(error_reporting()))) as $bit) {
    if (
$bit == 1) {
        echo 
array_search(pow(2$pot), get_defined_constants(true)['Core']). "<br>\n";
    }
   
$pot++;
}
?>
2017-11-24 19:24:12
http://php5.kiev.ua/manual/ru/errorfunc.constants.html
Автор:
PHP 7 makes E_STRICT irrelevant, reclassifying most of the errors as proper warnings, notices or E_DEPRECATED: https://wiki.php.net/rfc/reclassify_e_strict
2018-04-19 17:08:57
http://php5.kiev.ua/manual/ru/errorfunc.constants.html
A neat way to have a place in code to control error reporting configuration :)

<?php

$errorsActive 
= [
   
E_ERROR             => FALSE,
   
E_WARNING           => TRUE,
   
E_PARSE             => TRUE,
   
E_NOTICE            => TRUE,
   
E_CORE_ERROR        => FALSE,
   
E_CORE_WARNING      => FALSE,
   
E_COMPILE_ERROR     => FALSE,
   
E_COMPILE_WARNING   => FALSE,
   
E_USER_ERROR        => TRUE,
   
E_USER_WARNING      => TRUE,
   
E_USER_NOTICE       => TRUE,
   
E_STRICT            => FALSE,
   
E_RECOVERABLE_ERROR => TRUE,
   
E_DEPRECATED        => FALSE,
   
E_USER_DEPRECATED   => TRUE,
   
E_ALL               => FALSE,
];

error_reporting(
   
array_sum(
       
array_keys($errorsActive$search true)
    )
);

?>
2019-06-01 14:14:22
http://php5.kiev.ua/manual/ru/errorfunc.constants.html
Автор:
A shorter version of vladvarna's FriendlyErrorType($type)
<?php
function getErrorTypeByValue($type) {
   
$constants  get_defined_constants(true);

    foreach ( 
$constants['Core'] as $key => $value ) { // Each Core constant
       
if ( preg_match('/^E_/'$key  ) ) {    // Check error constants
           
if ( $type == $value 
                return( 
"$key=$value");
        }
    }
}   
// getErrorTypeByValue() 

echo "[".getErrorTypeByValue) . "]"PHP_EOL;
echo 
"[".getErrorTypeByValue) . "]"PHP_EOL;
echo 
"[".getErrorTypeByValue) . "]"PHP_EOL;
?>

Will give
    [E_ERROR=1]
    []
    [E_NOTICE=8]
2019-06-19 13:39:32
http://php5.kiev.ua/manual/ru/errorfunc.constants.html

    Поддержать сайт на родительском проекте КГБ