ErrorException

(PHP 5 >= 5.1.0, PHP 7, PHP 8)

Введение

Исключение в случае ошибки.

Обзор классов

Свойства

Примеры

Пример #1 Использование set_error_handler() для изменения сообщений об ошибках в ErrorException.

function exception_error_handler ( $severity , $message , $file , $line ) <
if (!( error_reporting () & $severity )) <
// Этот код ошибки не входит в error_reporting
return;
>
throw new ErrorException ( $message , 0 , $severity , $file , $line );
>
set_error_handler ( «exception_error_handler» );

/* вызываем исключение */
strpos ();
?>

Результатом выполнения данного примера будет что-то подобное:

Содержание

• ErrorException::__construct — Создаёт исключение
• ErrorException::getSeverity — Получает серьёзность исключения

User Contributed Notes 5 notes

As noted below, it’s important to realize that unless caught, any Exception thrown will halt the script. So converting EVERY notice, warning, or error to an ErrorException will halt your script when something harmlesss like E_USER_NOTICE is triggered.

It seems to me the best use of the ErrorException class is something like this:

function custom_error_handler ( $number , $string , $file , $line , $context )
<
// Determine if this error is one of the enabled ones in php config (php.ini, .htaccess, etc)
$error_is_enabled = (bool)( $number & ini_get ( ‘error_reporting’ ) );

// — FATAL ERROR
// throw an Error Exception, to be handled by whatever Exception handling logic is available in this context
if( in_array ( $number , array( E_USER_ERROR , E_RECOVERABLE_ERROR )) && $error_is_enabled ) <
throw new ErrorException ( $errstr , 0 , $errno , $errfile , $errline );
>

// — NON-FATAL ERROR/WARNING/NOTICE
// Log the error if it’s enabled, otherwise just ignore it
else if( $error_is_enabled ) <
error_log ( $string , 0 );
return false ; // Make sure this ends up in $php_errormsg, if appropriate
>
>
?>

Setting this function as the error handler will result in ErrorExceptions only being thrown for E_USER_ERROR and E_RECOVERABLE_ERROR, while other enabled error types will simply get error_log()’ed.

It’s worth noting again that no matter what you do, «E_ERROR, E_PARSE, E_CORE_ERROR, E_CORE_WARNING, E_COMPILE_ERROR, E_COMPILE_WARNING, and most of E_STRICT» will never reach your custom error handler, and therefore will not be converted into ErrorExceptions. Plan accordingly.

E_USER_WARNING, E_USER_NOTICE, and any other non-terminating error codes, are useless and act like E_USER_ERROR (which terminate) when you combine a custom ERROR_HANDLER with ErrorException and do not CATCH the error. There is NO way to return execution to the parent scope in the EXCEPTION_HANDLER.

( E_ALL );
define ( ‘DEBUG’ , true );
define ( ‘LINEBREAK’ , «\r\n» );

error :: initiate ( ‘./error_backtrace.log’ );

try
trigger_error ( «First error» , E_USER_NOTICE );
catch ( ErrorException $e )
print( «Caught the error: » . $e -> getMessage . «
\r\n» );

trigger_error ( «This event WILL fire» , E_USER_NOTICE );

trigger_error ( «This event will NOT fire» , E_USER_NOTICE );

abstract class error <

public static $LIST = array();

private function __construct () <>

public static function initiate ( $log = false ) <
set_error_handler ( ‘error::err_handler’ );
set_exception_handler ( ‘error::exc_handler’ );
if ( $log !== false ) <
if ( ! ini_get ( ‘log_errors’ ) )
ini_set ( ‘log_errors’ , true );
if ( ! ini_get ( ‘error_log’ ) )
ini_set ( ‘error_log’ , $log );
>
>

public static function err_handler ( $errno , $errstr , $errfile , $errline , $errcontext ) <
$l = error_reporting ();
if ( $l & $errno ) <

$exit = false ;
switch ( $errno ) <
case E_USER_ERROR :
$type = ‘Fatal Error’ ;
$exit = true ;
break;
case E_USER_WARNING :
case E_WARNING :
$type = ‘Warning’ ;
break;
case E_USER_NOTICE :
case E_NOTICE :
case @ E_STRICT :
$type = ‘Notice’ ;
break;
case @ E_RECOVERABLE_ERROR :
$type = ‘Catchable’ ;
break;
default:
$type = ‘Unknown Error’ ;
$exit = true ;
break;
>

$exception = new \ ErrorException ( $type . ‘: ‘ . $errstr , 0 , $errno , $errfile , $errline );

if ( $exit ) <
exc_handler ( $exception );
exit();
>
else
throw $exception ;
>
return false ;
>

function exc_handler ( $exception ) <
$log = $exception -> getMessage () . «\n» . $exception -> getTraceAsString () . LINEBREAK ;
if ( ini_get ( ‘log_errors’ ) )
error_log ( $log , 0 );
print( «Unhandled Exception» . ( DEBUG ? » — $log » : » ));
>

To add to the comments made by chris AT cmbuckley DOT co DOT uk about the ErrorException problem with args:

I noticed that the problem is in the ErrorException class itself, not the Exception class. When using just the exception class, it’s no longer an issue. Besides the args problem, the only difference between Exception and ErrorException in the stack trace is that the args are left out of the error handler exception function. I’m not sure if this was on purpose or not, but it shouldn’t hurt to show this information anyway.

So instead of using this broken extended class, you can ignore it and make your own extended class and avoid the problem all together:

class ErrorHandler extends Exception <
protected $severity ;

public function __construct ( $message , $code , $severity , $filename , $lineno ) <
$this -> message = $message ;
$this -> code = $code ;
$this -> severity = $severity ;
$this -> file = $filename ;
$this -> line = $lineno ;
>

public function getSeverity () <
return $this -> severity ;
>
>

function exception_error_handler ( $errno , $errstr , $errfile , $errline ) <
throw new ErrorHandler ( $errstr , 0 , $errno , $errfile , $errline );
>

set_error_handler ( «exception_error_handler» , E_ALL );

function A () <
$foo -> bar ; // Purposely cause error
>

try <
B ( ‘foobar’ );
> catch ( Exception $e ) <
var_dump ( $e -> getTrace ());
>

?>

The only thing I wish I could do was remove the entry for the error handler function because it’s quite irrelevant. Maybe that’s what they were trying to do with the ErrorException class? Either way, you can’t change it because the trace functions are final, and the variable is private.

I have been Googling all over the place for how to convert an E_NOTICE error into an exception, and I think I finally found a clean way to do it:

$lastError = error_get_last();
if ( !empty( $lastError ) ) <
throw new TemplateRenderingException($lastError[‘message’], $lastError[‘type’]);
>

Basically, if it’s something not system haulting it will likely hit this. Then you can throw whatever exception you want. Now, this is of course if you have a need. I did, because I wanted to clean up my output buffer if there was an error that skipped over it.

function exception_error_handler ( $errno , $errstr , $errfile , $errline ) <
throw new ErrorException ( $errstr , $errno , 0 , $errfile , $errline );
>
set_error_handler ( «exception_error_handler» );

/* Trigger exception */
strpos ();
?>

Please note that property $severity of class ErrorException is set to a constant zero for all kinds of errors in the above example.

I think it was a bug and tried to file a bug report, but it was closed as not a bug, so I could not say the above is wrong.

Let me show an example that uses $severity not as a constant:
(function ( $errno , $errstr , $errfile , $errline ) <
throw new ErrorException ( $errstr , 0 , $errno , $errfile , $errline );
>);

class MyClass <
public function methodA () <
echo( «methodA:\n» );
strpos ();
>

public function methodB () <
echo( «methodB:\n» );
trigger_error ( «warning message form methodB» , E_WARNING );
>

public function methodC () <
echo( «methodC:\n» );
throw new ErrorException ();
>

public function methodD () <
echo( «methodD:\n» );
throw new ErrorException ( ‘warning message from methodD’ , 0 ,
E_WARNING );
>

public function run ( $i ) <
if ( $i === 0 ) <
$this -> methodA ();
> else if ( $i === 1 ) <
$this -> methodB ();
> else if ( $i === 2 ) <
$this -> methodC ();
> else <
$this -> methodD ();
>
>

public function test () <
for ( $i = 0 ; $i 4 ; ++ $i ) <
try <
$this -> run ( $i );
> catch ( ErrorException $e ) <
if ( $e -> getSeverity () === E_ERROR ) <
echo( «E_ERROR triggered.\n» );
> else if ( $e -> getSeverity () === E_WARNING ) <
echo( «E_WARNING triggered.\n» );
>
>
>
>
>

$myClass = new MyClass ();
$myClass -> test ();
?>

Please note that methodC() uses (constructor of) class ErrorException with default parameters.

I believe it is the original intention to make $severity having default value of 1, which is exactly equal to E_ERROR.

Using property $code or Exception::getCode() to compare with E_* values could not do the same thing (as in methodC()), as $code has a default value of 0, and class Exception has it too, users may use $code for some other purposes.

Exception class and properties

The Exception class is the base class from which exceptions inherit. For example, the InvalidCastException class hierarchy is as follows:

The Exception class has the following properties that help make understanding an exception easier.

Property Name	Description
Data	An IDictionary that holds arbitrary data in key-value pairs.
HelpLink	Can hold a URL (or URN) to a help file that provides extensive information about the cause of an exception.
InnerException	This property can be used to create and preserve a series of exceptions during exception handling. You can use it to create a new exception that contains previously caught exceptions. The original exception can be captured by the second exception in the InnerException property, allowing code that handles the second exception to examine the additional information. For example, suppose you have a method that receives an argument that’s improperly formatted. The code tries to read the argument, but an exception is thrown. The method catches the exception and throws a FormatException. To improve the caller’s ability to determine the reason an exception is thrown, it is sometimes desirable for a method to catch an exception thrown by a helper routine and then throw an exception more indicative of the error that has occurred. A new and more meaningful exception can be created, where the inner exception reference can be set to the original exception. This more meaningful exception can then be thrown to the caller. Note that with this functionality, you can create a series of linked exceptions that ends with the exception that was thrown first.
Message	Provides details about the cause of an exception.
Source	Gets or sets the name of the application or the object that causes the error.
StackTrace	Contains a stack trace that can be used to determine where an error occurred. The stack trace includes the source file name and program line number if debugging information is available.

Most of the classes that inherit from Exception do not implement additional members or provide additional functionality; they simply inherit from Exception. Therefore, the most important information for an exception can be found in the hierarchy of exception classes, the exception name, and the information contained in the exception.

We recommend that you throw and catch only objects that derive from Exception, but you can throw any object that derives from the Object class as an exception. Note that not all languages support throwing and catching objects that do not derive from Exception.

Object Windows Exception; Create fail for window .

OS: Windows 7; 64 bit

I recently installed an older program that was functioning ok.

Now when it is launched I get an error window «ObjectWindows Exception» with the message «Create fail for window . «.

There were no deliberate changes to the system but obviously something has changed. I don’t know what happened or where to start looking for the issue.

Have you considered a Virtual Machine type solution?

Windows XP Mode (Windows 7 only, but not any of the Home versions) «You are not eligible to download Windows XP Mode. You must have Windows 7 Professional, Enterprise, or Ultimate to run Windows XP Mode». If you have an old XP CD (or other older Windows CD) available you can just download the Virtual Machine and skip the XP Mode download.

This covers the whole gambit of virtual machines in «Home» versions if you want to have a look at it. Of course you will need a licensed copy of XP to install and run in any of them (except XP Mode).

This example might or might not work for you with your program it uses the built-in Administrator account to perform the install?

«It seems that the «Run as administrator» command only gives you some administrative privileges, and they’re not enough to install Java (and OpenOffice, by association). In order to get around this, you need to actually log into the built-in administrator. Open a command prompt with admin rights by clicking start, typing cmd into the search/run box, and hitting CTRL-SHIFT-ENTER. At the prompt, type:

net user administrator /active:yes

Then log out of your regular account and back in as the built-in administrator, where you might be able to install the program. When you’re done, log back into your regular account and, for security purposes, disable the built-in administrator account using:

Error

Error objects are thrown when runtime errors occur. The Error object can also be used as a base object for user-defined exceptions. See below for standard built-in error types.

Description

Runtime errors result in new Error objects being created and thrown.

Error types

Besides the generic Error constructor, there are other core error constructors in JavaScript. For client-side exceptions, see Exception handling statements.

EvalError Creates an instance representing an error that occurs regarding the global function eval() . RangeError Creates an instance representing an error that occurs when a numeric variable or parameter is outside of its valid range. ReferenceError Creates an instance representing an error that occurs when de-referencing an invalid reference. SyntaxError Creates an instance representing a syntax error. TypeError Creates an instance representing an error that occurs when a variable or parameter is not of a valid type. URIError Creates an instance representing an error that occurs when encodeURI() or decodeURI() are passed invalid parameters. AggregateError Creates an instance representing several errors wrapped in a single error when multiple errors need to be reported by an operation, for example by Promise.any() . InternalError This API has not been standardized.

Creates an instance representing an error that occurs when an internal error in the JavaScript engine is thrown. E.g. «too much recursion».

Constructor

Static methods

Instance properties

Instance methods

Examples

Throwing a generic error

Usually you create an Error object with the intention of raising it using the throw keyword. You can handle the error using the try. catch construct:

Handling a specific error

You can choose to handle only specific error types by testing the error type with the error’s constructor property or, if you’re writing for modern JavaScript engines, instanceof keyword:

Custom Error Types

You might want to define your own error types deriving from Error to be able to throw new MyError() and use instanceof MyError to check the kind of error in the exception handler. This results in cleaner and more consistent error handling code.

See «What’s a good way to extend Error in JavaScript?» on StackOverflow for an in-depth discussion.

ES6 Custom Error Class

Versions of Babel prior to 7 can handle CustomError class methods, but only when they are declared with Object.defineProperty(). Otherwise, old versions of Babel and other transpilers will not correctly handle the following code without additional configuration.

Some browsers include the CustomError constructor in the stack trace when using ES2015 classes.

ES5 Custom Error Object

All browsers include the CustomError constructor in the stack trace when using a prototypal declaration.