PHP 8.4.0 RC2 available for testing

Öntanımlı Sabitler

Aşağıdaki sabitler PHP çekirdeğinin parçası olarak daima kullanılabilir durumdadır.

Bilginize: Bu sabit isimleri php.ini dosyasında kullanılabilir, fakat httpd.conf gibi PHP dışı yerlerde isimleri değil değerleri bit maskesi olarak kullanılabilir.

Hatalar ve Günlük Kaydı
Değer Sabit Açıklama Ek Bilgi
1 E_ERROR (int) Ölümcül çalışma anı hataları. Bellek ayırma sorunu gibi giderilemeyen hatalar bu sınıfa girer. Böyle hatalar betiğin çalışmasının durmasına sebep olur.  
2 E_WARNING (int) Çalışma anı uyarıları (ölümcül olmayan hatalar). Betiğin çalışması durmaz.  
4 E_PARSE (int) Derleme anı çözümleme hataları. Çözümleme hatalarını sadece çözümleyici üretir.  
8 E_NOTICE (int) Çalışma anı bildirimleri. Betikte bir hataya sebep olabilecek fakat betiğin normal çalışmasını esnasında oluşmayabilecek bir şeylerin saptandığını belirtir.  
16 E_CORE_ERROR (int) PHP'nin başlatılması sırasında oluşan ölümcül hatalar. PHP çekirdeği tarafından üretilmesi dışında E_ERROR gibidir.  
32 E_CORE_WARNING (int) PHP'nin başlatılması sırasında oluşan uyarılar (ölümcül olmayan hatalar). PHP çekirdeği tarafından üretilmesi dışında E_WARNING gibidir.  
64 E_COMPILE_ERROR (int) Ölümcül derleme anı hataları. Zend betik motoru tarafından üretilmesi dışında E_ERROR gibidir.  
128 E_COMPILE_WARNING (int) Derleme anı uyarıları (ölümcül olmayan hatalar). Zend betik motoru tarafından üretilmesi dışında E_WARNING gibidir.  
256 E_USER_ERROR (int) Kullanıcı üretimi hata iletileri. PHP işlevi trigger_error() tarafından PHP kodunda üretilmesi dışında E_ERROR gibidir.  
512 E_USER_WARNING (int) Kullanıcı üretimi uyarı iletileri. PHP işlevi trigger_error() tarafından PHP kodunda üretilmesi dışında E_WARNING gibidir.  
1024 E_USER_NOTICE (int) Kullanıcı üretimi bildirim iletileri. PHP işlevi trigger_error() tarafından PHP kodunda üretilmesi dışında E_NOTICE gibidir.  
2048 E_STRICT (int) Yazılan PHP kodunun ileriye dönük uyumluluğunu ve birlikte çalışabilirliğini en iyilemek amacıyla PHP tarafından yapılan önerileri etkin kılar.  
4096 E_RECOVERABLE_ERROR (int) Yakalanabilir ölümcül hata. Tehlikeli olma olasılığı bulunan bir hata oluştuğunu fakat yorumlayıcıyı kararsız durumda bırakmadığını belirtir. Hata, kullanıcı tarafından bir eylemci tanımlanarak yakalanmadığı (set_error_handler() işlevine bakınız) takdirde betik E_ERROR hatasıyla sonlanır.  
8192 E_DEPRECATED (int) Çalışma anı bildirimleri. Gelecek sürümlerle çalışmayacak kodlar hakkındaki uyarıları etkin kılar.  
16384 E_USER_DEPRECATED (int) Kullanıcı üretimi "kullanımı önerilmiyor" bildirimleri. PHP işlevi trigger_error() tarafından PHP kodunda üretilmesi dışında E_DEPRECATED gibidir.  
32767 E_ALL (int) Tüm hatalar, uyarılar ve bildirimler.  

Gerek sayısal gerekse simgesel olarak yukarıdaki değerler raporlanacak hataları belirten bir bit maskesi oluşturmakta kullanılabilir. Bu değerlerden bir bit maskesi oluşturmak veya bunları çözümlemek için bitsel işleçler kullanılabilir. php.ini içinde sadece '|', '~', '!', '^' ve '&' işleç karakterleri tanındığına dikkat edilmelidir.

add a note

User Contributed Notes 15 notes

up
26
Andy at Azurite (co uk)
13 years ago
-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 :-)
up
16
fadhilinjagi at gmail dot com
3 years ago
A simple and neat way to get the error level from the error code. You can even customize the error level names further.

<?php
$exceptions
= [
E_ERROR => "E_ERROR",
E_WARNING => "E_WARNING",
E_PARSE => "E_PARSE",
E_NOTICE => "E_NOTICE",
E_CORE_ERROR => "E_CORE_ERROR",
E_CORE_WARNING => "E_CORE_WARNING",
E_COMPILE_ERROR => "E_COMPILE_ERROR",
E_COMPILE_WARNING => "E_COMPILE_WARNING",
E_USER_ERROR => "E_USER_ERROR",
E_USER_WARNING => "E_USER_WARNING",
E_USER_NOTICE => "E_USER_NOTICE",
E_STRICT => "E_STRICT",
E_RECOVERABLE_ERROR => "E_RECOVERABLE_ERROR",
E_DEPRECATED => "E_DEPRECATED",
E_USER_DEPRECATED => "E_USER_DEPRECATED",
E_ALL => "E_ALL"
];

echo
$exceptions["1"];
$code = 256;
echo
$exceptions[$code];
?>

Output:
E_ERROR
E_USER_ERROR

This will need updating when PHP updates the error level names. Otherwise, it works just fine.
up
24
russthom at fivegulf dot com
12 years ago
[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
"";
}
?>
up
16
paulsnar
6 years ago
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
up
15
bbrokman at gmail dot com
5 years ago
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)
)
);

?>
up
12
cl at viazenetti dot de
6 years ago
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++;
}
?>
up
4
ali6236 at yahoo dot com
1 year ago
A better way to map error constant to their names (instead of switch) :

function getErrorName($code)
{
static $error_names = [
E_ERROR => 'E_ERROR',
E_WARNING => 'E_WARNING',
E_PARSE => 'E_PARSE',
E_NOTICE => 'E_NOTICE',
E_CORE_ERROR => 'E_CORE_ERROR',
E_CORE_WARNING => 'E_CORE_WARNING',
E_COMPILE_ERROR => 'E_COMPILE_ERROR',
E_COMPILE_WARNING => 'E_COMPILE_WARNING',
E_USER_ERROR => 'E_USER_ERROR',
E_USER_WARNING => 'E_USER_WARNING',
E_USER_NOTICE => 'E_USER_NOTICE',
E_STRICT => 'E_STRICT',
E_RECOVERABLE_ERROR => 'E_RECOVERABLE_ERROR',
E_DEPRECATED => 'E_DEPRECATED',
E_USER_DEPRECATED => 'E_USER_DEPRECATED',
];
return $error_names[$code] ?? '';
}
up
5
ahsankhatri1992 at gmail
8 years ago
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 "";
}
up
6
kezzyhko at NOSPAM dot semysha dot ru
8 years ago
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'], 1, 15, true))[$type];

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

?>
up
3
kaioker
3 years ago
super simple error code to human readable conversion:

function prettycode($code){
return $code == 0 ? "FATAL" : array_search($code, get_defined_constants(true)['Core']);
}
up
1
ErikBachmann
5 years ago
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( 1 ) . "]". PHP_EOL;
echo
"[".getErrorTypeByValue( 0 ) . "]". PHP_EOL;
echo
"[".getErrorTypeByValue( 8 ) . "]". PHP_EOL;
?>

Will give
[E_ERROR=1]
[]
[E_NOTICE=8]
up
1
Anonymous
8 years ago
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);
}
}
up
-2
PhpMyCoder
14 years ago
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.
up
-4
vladvarna at gmail dot com
12 years ago
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;
}
up
-4
damian at thebestisp dot dot dot com
8 years ago
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)
To Top