Delicious Bookmark this on Delicious Share on Facebook SlashdotSlashdot It! Digg! Digg

PHP : Language Reference : Operators : Error Control Operators

Error Control Operators

PHP supports one error control operator: the at sign (@). When prepended to an expression in PHP, any error messages that might be generated by that expression will be ignored.

If the track_errors feature is enabled, any error message generated by the expression will be saved in the variable $php_errormsg. This variable will be overwritten on each error, so check early if you want to use it.

/* Intentional file error */
$my_file = @file ('non_existent_file') or
   die (
"Failed opening file: error was '$php_errormsg'");

// this works for any expression, not just functions:
$value = @$cache[$key];
// will not issue a notice if the index $key doesn't exist.


The @-operator works only on expressions. A simple rule of thumb is: if you can take the value of something, you can prepend the @ operator to it. For instance, you can prepend it to variables, function and include() calls, constants, and so forth. You cannot prepend it to function or class definitions, or conditional structures such as if and foreach, and so forth.

See also error_reporting() and the manual section for Error Handling and Logging functions.


Currently the "@" error-control operator prefix will even disable error reporting for critical errors that will terminate script execution. Among other things, this means that if you use "@" to suppress errors from a certain function and either it isn't available or has been mistyped, the script will die right there with no indication as to why.

Code Examples / Notes » language.operators.errorcontrol


With set_error_handler() you bypass the standard error handler, which takes care of @.
if (!($fp = @fopen('not_a_file', 'r')))
 trigger_error("Can't open file!", E_USER_WARNING);
... generates ...
Warning: fopen("not_a_file", "r") - No such file or directory in index.php on line 19.
User Warning : Can't open file! in index.php on line 20.
... when I use my own error handler. With the standard error handler I only get the second warning.
If someone knows how to use @ with your own error handler, let me know.


When you check if an index of an array is set, you imply that the array itself already exists.
if ( isset ( $array [ 'index' ] ) ) {
would generate a notice if $array is not defined, but not if $array _is_ defined, but the index 'index' not.
And so on for nested arrays ofcourse


To webmaster at speedy dot co dot il:
it's not a bug. As the manual says, the @-operator works only on expressions, and isset() takes a variable, not expression, as its argument.


To suppress errors for a new class/object:
// Tested: PHP 5.1.2 ~ 2006-10-13
// Typical Example
$var = @some_function();
// Class/Object Example
$var = @new some_class();
// Does NOT Work!
//$var = new @some_class(); // syntax error
I found this most useful when connecting to a
database, where i wanted to control the errors
and warnings displayed to the client, while still
using the class style of access.

19-oct-2002 07:00

To suppress errors for a method inside a class, place the @ operator before the object and not before the method name.
// DO:
// DON'T:


To suppress error warnings for functions that use the error operator '@' in your own error handlers, I found a sentence on the set_error_handler() page that explains it:
To paraphrase, it says that PHP temporarily sets the value of error_reporting() to 0 when in the error handler.
So, if you have the following:
$fp = @fopen("non-existent-file", "r");
when your custom error handler function is called, you can check the value of error_reporting() like this:
function handler($type, $str, $file, $line, $info) {
   // don't respond to the error if it
   // was suppressed with a '@'
   if (error_reporting() == 0) return;
   // otherwise, handle the error

john chilton

To omelnyk:
It also says:
A simple rule of thumb is: if you can take the value of something, you can prepend the @ operator to it. For instance, you can prepend it to variables, function and include() calls....
" can prepend it to variables..."
I happen to use it with variables all the time, and have also noticed the (IMHO) odd result when trying to stifle errors when asking isset() about a nonexistent variable. However, it does make more sense to use @isset($foo) than isset(@$foo) to me anyway...


The @ operator can also be prepended to literals (like strings), as they're also statements -- it will suppress any notice about uninitialized variables. If you want to silence a more complex expression (@ is unary), use braces.
// variable interpolation
$str = @"Then I said: '$maybeunset'.";
// integer stuffs
$result = @2 * 3 / 0; // = @(2) * 3 / 0 - WRONG (warning)
$result = @(2 * 3 / 0); // RIGHT (no warning), $result is false
@John Chilton's post: As omelnyk said, isset is a language construct and NOT a function, and an @ token is not allowed there. @isset makes no sense, because under ANY circumstances isset stays quiet.
Also, "using it with variables all the time" is a VERY bad idea, because it will make your code EXTREMELY slow. Crank your error_reporting down then.


taking the value of a non existant element:
  $foo = @$array['not_here']
will work as described, setting $foo to NULL,
but taking a *reference* to a non-existant element:
  $foo =& @$array['not_here']
will create the element with a NULL value, which $foo will then referece.
 -- code till dawn, mark meves

webmaster __at__ digitalanime __dot__ nl

Someone over here wanted to know how to use the @ in your error handler... It's easy:
function my_error_handler(.......)
 if(error_reporting() == 0) // error_reporting() = 0, so it was called with @ in front of it
   // do nothing
  // do something

25-apr-2003 02:24

It should be noted that suppressed error reporting is inherited, so to speak.
Consider this function:
function warning() {
$return = 10 / 0;
return $return;
This line will produce a warning;
While these will not:
This might not be so obvious for some people; I know I didn't expect this behaviour.


If you wish to display some text when an error occurs, echo doesn't work. Use print instead. This is explained on the following link 'What is the difference between echo and print?':
It says "print can be used as part of a more complex expression where echo cannot".
Also, you can add multiple code to the result when an error occurs by separating each line with "and". Here is an example:
$my_file = @file ('non_existent_file') or print 'File not found.' and $string = ' Honest!' and print $string and $fp = fopen ('error_log.txt', 'wb+') and fwrite($fp, $string) and fclose($fp);
A shame you can't use curly brackets above to enclose multiple lines of code, like you can with an if statement or a loop. It could make for a single long line of code. You could always call a function instead.


If you want to log all the error messages for a php script from a session you can use something like this:
 function error($error, $return=FALSE) {
  global $php_errormsg;
  if(isset($_SESSION['php_errors'])) {
$_SESSION['php_errors'] = array();    
 $_SESSION['php_errors'][] = $error; // Maybe use $php_errormsg
 if($return == TRUE) {
   $message = "";
  foreach($_SESSION['php_errors'] as $php_error) {
$messages .= $php_error."\n";
return $messages; // Or you can use use $_SESSION['php_errors']
Hope this helps someone...


if you create a new variable by assigning to it the error
suppressed value of an unset variable, the new variable
will be set, with a value of (I believe) null:
$new_variable                // previously not set
   = @$nonexistent_variable; // also not set
$next_variable = $new_variable // no warning generated


I don't know if this is a feature or bug, but this doesn't work:
On the other hand, this works:

13-dec-2006 01:52

error_reporting()==0 for detecting the @ error suppression assumes that you did not set the error level to 0 in the first place.
However, typically if you want to set your own error handler, you would set the error_reporting to 0. Therefore, an alternative to detect the @ error suppression is required.


Better use the function trigger_error() (
to display defined notices, warnings and errors than check the error level your self. this lets you write messages to logfiles if defined in the php.ini, output
messages in dependency to the error_reporting() level and suppress output using the @-sign.

Change Language

Follow Navioo On Twitter
Operator Precedence
Arithmetic Operators
Assignment Operators
Bitwise Operators
Comparison Operators
Error Control Operators
Execution Operators
Incrementing/Decrementing Operators
Logical Operators
String Operators
Array Operators
Type Operators
eXTReMe Tracker