error_log
It might be a good idea to include E_COMPILE_ERROR in error_reporting.
If you have a customer error handler that does not output warnings, you may get a white screen of death if a "require" fails.
Example:
<?php
error_reporting(E_ERROR | E_WARNING | E_PARSE);
function myErrorHandler($errno, $errstr, $errfile, $errline) {
// Do something other than output message.
return true;
}
$old_error_handler = set_error_handler("myErrorHandler");
require "this file does not exist";
?>
To prevent this, simply include E_COMPILE_ERROR in the error_reporting.
<?php
error_reporting(E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);
?>
error_reporting
(PHP 4, PHP 5)
error_reporting — definisce quali errori di PHP vengono restituiti
Descrizione
int error_reporting
([ int
$livello
] )La funzione error_reporting() imposta la direttiva error_reporting a runtime. PHP ha parecchi livelli d'errore, usando questa funzione si imposta il livello per la durata (runtime) dello script.
Elenco dei parametri
-
livello -
Il nuovo livello di error_reporting. Accetta una maschera di bit o una costante named. L'utilizzo delle costanti named è caldamente consigliato per assicurare la compatibilità con versioni future. All'aggiungere di livelli di errore, la gamma degli interi viene incrementata, perciò vecchi livelli di errore basati sull'intero non si comporteranno sempre come ci si aspetta.
Le costanti disponibili sono elencate qui sotto. Il significato di questi livelli d'errore è descritto nelle costanti predefinite.
error_reporting() valori dei bit valore costante 1 E_ERROR 2 E_WARNING 4 E_PARSE 8 E_NOTICE 16 E_CORE_ERROR 32 E_CORE_WARNING 64 E_COMPILE_ERROR 128 E_COMPILE_WARNING 256 E_USER_ERROR 512 E_USER_WARNING 1024 E_USER_NOTICE 6143 E_ALL 2048 E_STRICT 4096 E_RECOVERABLE_ERROR
Valori restituiti
Restituisce il precedente livello di error_reporting .
Log delle modifiche
| Versione | Descrizione |
|---|---|
| 5.0.0 | Inserita E_STRICT (non fa parte di E_ALL). |
| 5.2.0 | Inserita E_RECOVERABLE_ERROR. |
| 6 | E_STRICT è diventata parte di E_ALL. |
Esempi
Example #1 esempi error_reporting()
<?php
// Spegni tutte le segnalazioni d'errore
error_reporting(0);
// Comunica gli errori semplici di esecuzione
error_reporting(E_ERROR | E_WARNING | E_PARSE);
// Anche la comunicazone di E_NOTICE può essere utile (per avvisare di
// variabili non inizializzate od intercettare nomi di variabili errati...)
error_reporting(E_ERROR | E_WARNING | E_PARSE | E_NOTICE);
// Comunica tutti gli errori eccetto E_NOTICE
// questo è il valore di default in php.ini
error_reporting(E_ALL ^ E_NOTICE);
// Comunica tutti gli errori PHP (il valore 63 può essere usato in PHP 3)
error_reporting(E_ALL);
// Stesso effetto di error_reporting(E_ALL);
ini_set('error_reporting', E_ALL);
?>
Note
Avviso
La maggior parte degli errori E_STRICT sono valutati
al momento della compilazione, quindi questi errori non sono riportati nello script in cui
error_reporting è modificato
per includere gli errori E_STRICT (e viceversa).
add a note
User Contributed Notes
error_reporting
teynon1 at gmail dot com
09-Feb-2012 12:50
ywarnier at beeznest dot org
03-Aug-2011 01:56
Setting error_reporting in your VirtualHost has to be done through a numerical value which is the result of the options you choose summed up from the values of these options, as defined on the constants page for the error management functions: http://www.php.net/manual/en/errorfunc.constants.php
As a result, E_ALL & ~E_NOTICE would be set this way (this automatically excludes E_DEPRECATED AND E_USER_DEPRECATED):
php_value error_reporting 6135
whereas E_ALL (excluding the deprecated levels) would be set this way:
php_value error_reporting 6143
The difference between those two values is 8, which is the value of the constant for E_NOTICE.
info at hyperjoint dot com
12-May-2011 11:19
Setting error_reporting to values which are not defined by the actually used PHP version may result in unpredictable behaviour. Since I often swap between server I use this:
<?php
function safe_error_reporting($level=null)
{
$e_all=defined('E_STRICT')?E_ALL|E_STRICT:E_ALL;
if(isset($level))$level=$level & $e_all;
return error_reporting($level);
}
?>
This
- gets E_ALL (inklusive E_STRICT if defined)
- filters level by E_ALL
- sets filtered error_reporting
Khalid
01-May-2011 05:08
When using joomla 1.6 in the backend. i see a message is desplayed: Strict Standards: Only variables should be assigned by reference in C:\xampp\htdocs\plugins\search\modules\modules.php on line 63
rojaro at gmail dot com
05-Dec-2010 06:55
To enable error reporting for *ALL* error messages including every error level (including E_STRICT, E_NOTICE etc.), simply use:
<?php error_reporting(-1); ?>
keithm at aoeex dot com
14-Jun-2010 03:23
Some E_STRICT errors seem to be thrown during the page's compilation process. This means they cannot be disabled by dynamically altering the error level at run time within that page.
The work-around for this was to rename the file and replace the original with a error_reporting() call and then a require() call.
Ex, rename index.php to index.inc.php, then re-create index.php as:
<?php
error_reporting(E_ALL & ~(E_STRICT|E_NOTICE));
require('index.inc.php');
?>
That allows you to alter the error reporting prior to the file being compiled.
I discovered this recently when I was given code from another development firm that triggered several E_STRICT errors and I wanted to disable E_STRICT on a per-page basis.
roberto at spadim dot com dot br
29-Jan-2010 05:00
see more information about php 5.3 deprecated errors
http://php.net/manual/en/migration53.deprecated.php
misplacedme at gmail dot com
09-Jun-2009 07:25
I always code with E_ALL set.
After a couple of pages of
<?php
$username = (isset($_POST['username']) && !empty($_POST['username']))....
?>
I made this function to make things a little bit quicker. Unset values passed by reference won't trigger a notice.
<?php
function test_ref(&$var,$test_function='',$negate=false) {
$stat = true;
if(!isset($var)) $stat = false;
if (!empty($test_function) && function_exists($test_function)){
$stat = $test_function($var);
$stat = ($negate) ? $stat^1 : $stat;
}
elseif($test_function == 'empty') {
$stat = empty($var);
$stat = ($negate) ? $stat^1 : $stat;
}
elseif (!function_exists($test_function)) {
$stat = false;
trigger_error("$test_function() is not a valid function");
}
$stat = ($stat) ? true : false;
return $stat;
}
$a = '';
$b = '15';
test_ref($a,'empty',true); //False
test_ref($a,'is_int'); //False
test_ref($a,'is_numeric'); //False
test_ref($b,'empty',true); //true
test_ref($b,'is_int'); //False
test_ref($b,'is_numeric'); //false
test_ref($unset,'is_numeric'); //false
test_ref($b,'is_number'); //returns false, with an error.
?>
ecervetti at orupaca dot fr
24-Mar-2009 06:54
It could save two minutes to someone:
E_ALL & ~E_NOTICE integer value is 6135
Daz Williams (The Northeast)
17-Feb-2009 10:03
Only display php errors to the developer...
<?php
if($_SERVER['REMOTE_ADDR']=="00.00.00.00")
{
ini_set('display_errors','On');
}
else
{
ini_set('display_errors','Off');
}
?>
Just replace 00.00.00.00 with your ip address.
info at hephoz dot de
13-Aug-2008 11:34
If you just see a blank page instead of an error reporting and you have no server access so you can't edit php configuration files like php.ini try this:
- create a new file in which you include the faulty script:
<?php
error_reporting(E_ALL);
ini_set("display_errors", 1);
include("file_with_errors.php");
?>
- execute this file instead of the faulty script file
now errors of your faulty script should be reported.
this works fine with me. hope it solves your problem as well!
kc8yds at gmail dot com
10-Aug-2008 04:45
this is to show all errors for code that may be run on different versions
for php 5 it shows E_ALL^E_STRICT and for other versions just E_ALL
if anyone sees any problems with it please correct this post
<?php
ini_set('error_reporting', version_compare(PHP_VERSION,5,'>=') && version_compare(PHP_VERSION,6,'<') ?E_ALL^E_STRICT:E_ALL);
?>
derek at darkcolors dot com
26-May-2008 06:12
I had the problem that if there was an error, php would just give me a blank page. Any error at all forced a blank page instead of any output whatsoever, even though I made sure that I had error_reporting set to E_ALL, display_errors turned on, etc etc. But simply running the file in a different directory allowed it to show errors!
Turns out that the error_log file in the one directory was full (2.0 Gb). I erased the file and now errors are displayed normally. It might also help to turn error logging off.
bbaez at biospectra dot com
09-May-2007 10:02
frederick noted this in 2005 but want to stress the point here
If you set error_reporting in httpd.conf or within a script (some PHP versions) then you must use the integer value and not the string:
Example httpd.conf:
E_ALL ^ E_NOTICE would be:
php_value error_reporting 6135
otherwise the error will not display during output.
antickon AT gmail.com
03-Apr-2007 10:21
regarding what vdephily at bluemetrix dot com said ( see http://be.php.net/manual/en/function.error-reporting.php#50228 )
<?php
echo $foobar->field;
?>
also initializes $foobar (as an instance of stdClass), so this code will not cause any notices.
bitagenda at gmail dot com
08-Mar-2007 12:36
A simple and effective way to catch Fatal errors.
From here you can go forward with your own ideas and elaborate a detailed error report.
The principle is simple and ready to test on your system
Fatal errors are not currently catched and you should have display errors off in production sites, but may be you need to test the system so you want a fast an easy way to see fatal errors in your currently running site, without the users seeing those Fatal errors as recomended.
You must have this function
<?php
function catchFatalErrors($p_OnOff='On'){
ini_set('display_errors','On');
$phperror='><div id="phperror" style="display:none">';
ini_set('error_prepend_string',$phperror);
$phperror='</div>><form name="catcher" action="/sos.php" method="post" ><input type="hidden" name="fatal" value=""></form> <script> document.catcher.fatal.value = document.getElementById("phperror").innerHTML; document.catcher.submit();</script>';
ini_set('error_append_string',$phperror);
}
Now activate your fatal error catcher
catchFatalErrors();
?>
Just to test write this inexistent function
<?php
Bitagenda();
?>
That's all. As you can see there will be a form posted with action="/sos.php", of course you can name this page at your liking, in this case is at the site's root.
Have ready your page sos.php, and elaborate on that. Of course change the mail address to yours,and display a message to the user at your liking.
<?php
if (isset($_POST['fatal'])){
error_log($_POST['fatal'],1,'[email protected]');
}
?>
"System Out of Service. Thanks for waiting."
The other fact about this handler is that even if you do not redirect the Fatal Error, prepending
><div style="display:none">
and appending
</div>
Then writting yor personal message
" Sorry, fatal bug."
Will hide the fatal error message from the user, but will be visible in the browsers soure code view.
What happens if you redirect the page before displaying the error? I don´t know, have not tested, but at least you could do it to alert you that a fatal error exists and possibly the fatal error is not displayed (leading to security and at the same time catching the fatal error). Then you could activate this error handler with post-redirection to see what's going on.
;o)
Bitagenda
Alex
18-Jan-2007 07:43
error_reporting() may give unexpected results if the @ error suppression directive is used.
<?php
@include 'config.php';
include 'foo.bar'; // non-existent file
?>
config.php
<?php
error_reporting(0);
?>
will throw an error level E_WARNING in relation to the non-existent file (depending of course on your configuration settings). If the suppressor is removed, this works as expected.
Alternatively using ini_set('display_errors', 0) in config.php will achieve the same result. This is contrary to the note above which says that the two instructions are equivalent.
silvan at NOSPAM dot example dot com
03-Oct-2006 11:38
On a shared debugging and production server it is convenient to use
<?php error_reporting(E_ALL); ?>
for debugging.
This will not help in case of parsing errors, so make sure you enable at least E_PARSE in your php.ini. Parse errors should not exist in production scripts.
Still, sometimes your script will not get executed even though no parse error is displayed (just a blank page/ no output at all). As far as I know this only happens when you redeclare a user function or class.
eg.
<?php
error_reporting(E_ALL);
function a(){}
function a(){}
?>
This prevents your script from running like a parse error, but is in fact a fatal run-time error (E_ERROR). Other fatal run-time errors will allow your script to apply the error_reporting, when it is executed before the
error occurs (eg. put error_reporting on the first line of code.)
Chris
09-May-2006 06:32
I found some simple mistakes in the functions I posted yesterday, so here are the corrected versions.
And a good advice: never code in the middle of the night ;)
<?php
function error2string($value)
{
$level_names = array(
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' );
if(defined('E_STRICT')) $level_names[E_STRICT]='E_STRICT';
$levels=array();
if(($value&E_ALL)==E_ALL)
{
$levels[]='E_ALL';
$value&=~E_ALL;
}
foreach($level_names as $level=>$name)
if(($value&$level)==$level) $levels[]=$name;
return implode(' | ',$levels);
}
?>
<?php
function string2error($string)
{
$level_names = 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_ALL' );
if(defined('E_STRICT')) $level_names[]='E_STRICT';
$value=0;
$levels=explode('|',$string);
foreach($levels as $level)
{
$level=trim($level);
if(defined($level)) $value|=(int)constant($level);
}
return $value;
}
?>
the_bug_the_bug at hotmail dot com
23-Apr-2006 11:20
In response to simon at firepages dot com dot au below:
I wrote a shorter more efficient function which will return a string containing the names of the error levels set in the .ini file:
<?php
function error_level_tostring($intval, $separator)
{
$errorlevels = array(
2047 => 'E_ALL',
1024 => 'E_USER_NOTICE',
512 => 'E_USER_WARNING',
256 => 'E_USER_ERROR',
128 => 'E_COMPILE_WARNING',
64 => 'E_COMPILE_ERROR',
32 => 'E_CORE_WARNING',
16 => 'E_CORE_ERROR',
8 => 'E_NOTICE',
4 => 'E_PARSE',
2 => 'E_WARNING',
1 => 'E_ERROR');
$result = '';
foreach($errorlevels as $number => $name)
{
if (($intval & $number) == $number) {
$result .= ($result != '' ? $separator : '').$name; }
}
return $result;
}
?>
P.S. With a little modification this function can be made to show the string values of any enumeration.
dave at davidhbrown dot us
06-Apr-2006 01:51
The example of E_ALL ^ E_NOTICE is a 'bit' confusing for those of us not wholly conversant with bitwise operators.
If you wish to remove notices from the current level, whatever that unknown level might be, use & ~ instead:
<?php
//....
$errorlevel=error_reporting();
error_reporting($errorlevel & ~E_NOTICE);
//...code that generates notices
error_reporting($errorlevel);
//...
?>
^ is the xor (bit flipping) operator and would actually turn notices *on* if they were previously off (in the error level on its left). It works in the example because E_ALL is guaranteed to have the bit for E_NOTICE set, so when ^ flips that bit, it is in fact turned off. & ~ (and not) will always turn off the bits specified by the right-hand parameter, whether or not they were on or off.
DarkGool
19-Aug-2005 03:30
In phpinfo() error reporting level display like a bit (such as 4095)
Maybe it is a simply method to understand what a level set on your host
if you are not have access to php.ini file
<?php
$bit = ini_get('error_reporting');
while ($bit > 0) {
for($i = 0, $n = 0; $i <= $bit; $i = 1 * pow(2, $n), $n++) {
$end = $i;
}
$res[] = $end;
$bit = $bit - $end;
}
?>
In $res you will have all constants of error reporting
$res[]=int(16) // E_CORE_ERROR
$res[]=int(8) // E_NOTICE
...
fredrik at demomusic dot nu
22-Jul-2005 09:24
Remember that the error_reporting value is an integer, not a string ie "E_ALL & ~E_NOTICE".
This is very useful to remember when setting error_reporting levels in httpd.conf:
Use the table above or:
<?php
ini_set("error_reporting", E_YOUR_ERROR_LEVEL);
echo ini_get("error_reporting");
?>
To get the appropriate integer for your error-level. Then use:
php_admin_value error_reporting YOUR_INT
in httpd.conf
I want to share this rather straightforward tip as it is rather annoying for new php users trying to understand why things are not working when the error-level is set to (int) "E_ALL" = 0...
Maybe the PHP-developers should make ie error_reporting("E_ALL"); output a E_NOTICE informative message about the mistake?
phpfanat at yandex dot ru
22-Feb-2005 01:03
If you get a weird mysql warnings like "Warning: mysql_query() [http://www.mysql.com/doc]: Your query requires a full tablescan...", don't look for error_reporting settings - it's set in php.ini.
You can turn it off with
ini_set("mysql.trace_mode","Off");
in your script
And, as of my opinion, it should be NOTICE, not WARNING level.
vdephily at bluemetrix dot com
21-Feb-2005 07:40
Note that E_NOTICE will warn you about uninitialized variables, but assigning a key/value pair counts as initialization, and will not trigger any error :
<?php
error_reporting(E_ALL);
$foo = $bar; //notice : $bar uninitialized
$bar['foo'] = 'hello'; // no notice, although $bar itself has never been initialized (with "$bar = array()" for example)
$bar = array('foobar' => 'barfoo');
$foo = $bar['foobar'] // ok
$foo = $bar['nope'] // notice : no such index
?>
Fernando Piancastelli
13-Dec-2004 05:23
The error_reporting() function won't be effective if your display_errors directive in php.ini is set to "Off", regardless of level reporting you set. I had to set
display_errors = On
error_reporting = ~E_ALL
to keep no error reporting as default, but be able to change error reporting level in my scripts.
I'm using PHP 4.3.9 and Apache 2.0.
ferozzahid [at] usa [dot] com
07-Sep-2004 09:31
To be enable to switch between error_reporting during development and release phases, one can define say 'php_error_reporting' in the main configuration file (ini like file: no PHP) for the application as:
# config.ini
# PHP error reporting. supported values are given below.
# 0 - Turn off all error reporting
# 1 - Running errors
# 2 - Running errors + notices
# 3 - All errors except notices and warnings
# 4 - All errors except notices
# 5 - All errors
php_error_reporting=4
# config.ini ends
Setting error_reporting in PHP files would be something like the code below, assuming the function getinivar() returns the variable value from the configuration file.
<?php
// setting PHP error reporting
switch(getinivar('php_error_reporting')) {
case 0: error_reporting(0); break;
case 1: error_reporting(E_ERROR | E_WARNING | E_PARSE); break;
case 2: error_reporting(E_ERROR | E_WARNING | E_PARSE | E_NOTICE); break;
case 3: error_reporting(E_ALL ^ (E_NOTICE | E_WARNING)); break;
case 4: error_reporting(E_ALL ^ E_NOTICE); break;
case 5: error_reporting(E_ALL); break;
default:
error_reporting(E_ALL);
}
?>
Feroz Zahid.
jernberg at fairytale dot se
26-Feb-2003 07:27
tip: if you want your error_reporting()-setting to work with your own error handler you could simply check the error number against the current error bitmask.
<?php
function myErrorHandler( $errno, $errstr, $errfile, $errline )
{
$replevel = error_reporting();
if( ( $errno & $replevel ) != $errno )
{
// we shall remain quiet.
return;
}
echo( "error....." );
}
?>
rbt at zort.ca
09-Feb-2002 12:25
It should be noted that in apache.conf files the defined values (constants) don't work. For E_ALL logging, one would use:
php_admin_value error_reporting 2047
j dot schriver at vindiou dot com
02-Oct-2000 04:37
error_reporting() has no effect if you have defined your own error handler with set_error_handler()
[Editor's Note: This is not quite accurate.
E_ERROR, E_PARSE, E_CORE_ERROR, E_CORE_WARNING, E_COMPILE_ERROR and E_COMPILE_WARNING error levels will be handled as per the error_reporting settings.
All other levels of errors will be passed to the custom error handler defined by set_error_handler().
Zeev Suraski suggests that a simple way to use the defined levels of error reporting with your custom error handlers is to add the following line to the top of your error handling function:
if (!($type & error_reporting())) return;
[email protected]]
03-Feb-2000 03:31
The E_NOTICE error reporting level reports the use of undefined variables as an error.
For example:
error_reporting(E_ALL); # Set error reporting to highest level
if ($foo) # This will generate an error
print "bar"; # because $foo is not defined
To avoid this behavior, use isset to test if the given
variable has been defined.
For example:
error_reporting(E_ALL);
if (isset ($foo))
print "bar";
webmaster at l-i-e dot com
21-May-1999 07:13
[Editor's Note: E_ALL will contain the result of OR'ing all of the applicable error constants together. For PHP 3, this will be the first 4 E_xxx constants. For PHP 4, this will be all constants. ]
There is also an E_ALL which is the first 4 E_xxx added up for you...