PHP: exceptions vs errors?

Question

Maybe I'm missing it somewhere in the PHP manual, but what exactly is the difference between an error and an exception? The only difference that I can see is that errors and exceptions are handled differently. But what causes an exception and what causes an error?

user_91914 · Answer

Exceptions are thrown - they are intended to be caught. Errors are generally unrecoverable. Lets say for instance - you have a block of code that will insert a row into a database. It is possible that this call fails (duplicate ID) - you will want to have a "Error" which in this case is an "Exception". When you are inserting these rows, you can do something like this

try {
  $row->insert();
  $inserted = true;
} catch (Exception $e) {
  echo "There was an error inserting the row - ".$e->getMessage();
  $inserted = false;
}

echo "Some more stuff";

Program execution will continue - because you 'caught' the exception. An exception will be treated as an error unless it is caught. It will allow you to continue program execution after it fails as well.

Kris_18565 · Answer

I usually set_error_handler to a function that takes the error and throws an exception so that whatever happens i'll just have exceptions to deal with. No more @file_get_contents just nice and neat try/catch.

In debug situations i also have an exception handler that outputs an asp.net like page. I'm posting this on the road but if requested I will post example source later.

edit:

Addition as promised, I've cut and pasted some of my code together to make a sample.

_Context;
    }
    public function setContext( $value )
    {
        $this->_Context = $value;
    }
    
    public function __construct( $code, $message, $file, $line, $context )
    {
        parent::__construct( $message, $code );

        $this->file = $file;
        $this->line = $line;
        $this->setContext( $context );
    }
}

/**
 * Inspire to write perfect code. everything is an exception, even minor warnings.
 **/
function error_to_exception( $code, $message, $file, $line, $context )
{
    throw new ErrorOrWarningException( $code, $message, $file, $line, $context );
}
set_error_handler( 'error_to_exception' );

function global_exception_handler( $ex )
{
    ob_start();
    dump_exception( $ex );
    $dump = ob_get_clean();
    // send email of dump to administrator?...

    // if we are in debug mode we are allowed to dump exceptions to the browser.
    if ( defined( 'DEBUG' ) && DEBUG == true )
    {
        echo $dump;
    }
    else // if we are in production we give our visitor a nice message without all the details.
    {
        echo file_get_contents( 'static/errors/fatalexception.html' );
    }
    exit;
}

function dump_exception( Exception $ex )
{
    $file = $ex->getFile();
    $line = $ex->getLine();

    if ( file_exists( $file ) )
    {
        $lines = file( $file );
    }
    
?>
    
        <?= $ex->getMessage(); ?>
        
    
    
        Uncaught 
        getMessage(); ?>
        
            An uncaught  was thrown on line  of file  that prevented further execution of this request.
        
        Where it happened:
        
        
        
            
                 0 && $i < count( $lines ) ) : ?>
                    
                        
                    
                        
                    
                
            
        
        

        getTrace() ) ) : ?>
        Stack trace:
            getTrace() as $i => $trace ) : ?>
                    
                
                    
                        File
                        Line
                        Class
                        Function
                        Arguments
                    
                
                
                
                        
                        
                        
                        
                        
                            
                                 $arg ) : ?>
                                    
                                     
                                
                            
                            NULL
                            
                        
                    
                
                
            
        
            getTraceAsString(); ?>

Alex_16668 · Answer

One thing to add here is about handling exceptions and errors. For the purpose of the application developer, both errors and exceptions are "bad things" that you want to record to learn about the problems that your application has - so that your customers have a better experience in the long run.

So it makes sense to write an error handler that does the same thing as what you do for exceptions.

user_635364 · Answer

From PHP: Exceptions - Manual:

As of PHP 7.1.0, a catch block may specify multiple exceptions using the pipe (|) character. This is useful for when different exceptions from different class hierarchies are handled the same.

try {
  // do something
} catch (Error | Exception $e) {
  echo $e->getMessage();
}

altCognito_38971 · Answer

Exceptions are thrown intentionally by code using a throw, errors... not so much.

Errors come about as a result of something which isn't handled typically. (IO errors, TCP/IP errors, null reference errors)

user_6679873 · Answer

You may add this comment

function doSomething()
{
   /** @noinspection PhpUnhandledExceptionInspection */
   throw new Exception();
}

PHP: exceptions vs errors?

12 Answers