PHP5 exception handling, error throwing and callback functions, etc.

error_reporting(E_ALL&~E_NOTICE); // In addition to E_NOTICE, other exceptions will be triggered (the binary operation result of E_ALL&~E_NOTICE is: the value of the corresponding bit of E_NOTICE is set to 0) try-catch cannot be automatically loaded in the class Valid within function __autoload().
try-catch cannot be used to catch exceptions and errors, such as errors triggered by trigger_error(). Exceptions and errors are different.
try{
// you codes that maybe cause an error
}catch(Exception $err){ // This error object needs to declare the type, Exception is the system default exception handling class
echo $err->getMessage();
 }

//thrown can throw an exception, such as: thrown new Exception('an error'); one example:

try {
if ( empty( $var1 ) ) throw new NotEmptyException();
if ( empty( $var2 ) ) throw new NotEmptyException();
if ( ! preg_match() ) throw new InvalidInputException( );
$model->write();
$template->render( 'success' );
} catch ( NotEmptyException $e ) {
$template->render( 'error_empty' );
} catch (InvalidInputException $e) {
$template->render( 'error_preg' );
}

Exception class structure: most of the methods are prohibited from being overridden (final)

Exception {
/* attribute*/
protected string $message ;
protected int $code ;
protected string $file ;
protected int $line ;
/* method*/
public __construct ([ string $message = "" [, int $code = 0 [, Exception $previous = null]]] )
final public string getMessage ( void ) //The message thrown by the exception
final public Exception getPrevious ( void ) //Previous Exception
final public int getCode (void) //Exception code, this is user-defined
final public string getFile (void) //The file path where the exception occurred
final public int getLine (void) //The line where the exception occurred
final public array getTrace (void) //Exception tracking information (array)
final public string getTraceAsString (void) //Exception tracking information (string)
public string __toString (void) //Trying to treat the exception object directly as a string The return value of calling the sub-function when used
final private void __clone (void) //Called when cloning the exception object
}

Extended exception class try-catch can have multiple catch clauses. Starting from the first catch clause, if the exception variable type in the clause matches the exception type thrown by the throw statement, the clause will be executed and no other catch clauses will be executed. clause, otherwise continue to try the next catch clause. Since Exception is the base class of all exception classes, the exceptions thrown will match it. If you use different processing methods according to different exception types, you should use Exception type The catch clause goes last. Exception is the base class of all exceptions. You can extend the exception class according to actual needs.

calss MyException extends Exception{
public errType = 'default';
public function __construct($errType=''){
$this->errType = $errType;
}
}
thrown new MyException (); //Throw an exception
try{
// you codes that maybe cause an error
}catch(MyException $err){ // This error object needs to declare the type
echo $err->errType();
}catch(ErrorException $err){ //ErrorException is an exception class added in PHP 5, inherited from Exception
echo 'error !';
}catch(Exception $err){
redirect('/error.php');
}

You may determine the type of exception in the catch clause, or decide whether to handle the exception based on code and other information. If the code you unload the catch clause cannot properly handle the caught exception, you can continue to throw it within the catch clause. Exception occurred.

3. Exception callback function set_exception_handler(callback functionName) //This function will be called when an exception of Exception or its subclass occurs function exceptionHandlerFun($errObj){ // Exception exception callback function has only one parameter, which is the thrown exception object. //....... }

Exception exception callback function cannot eliminate the exception by returning true like set_error_handler's callback function. Even if the callback function handles the exception, subsequent code will not continue to be executed, so if you want to continue executing subsequent code, try-catch must be used . But there is an exception: the script end callback function can be executed, and the callback function can be executed even if the thrown exception is not handled. register_shutdown_function(callback functionName[,argument1,argument2,...]); For example:

function shutdownfunction(){
echo 'script is end';
}
register_shutdown_function("shutdownfunction");

Because shutdownfunction() is executed at the end of the script, this callback function can call a function anywhere in the script, even if the function is defined after the error is thrown (the function definition is in the script Completed during compilation).

4. trigger_error(string errorMsg[,int user_error_type]) This function is used to actively trigger an error: user_error_type can only be the value of E_ALL, E_USER_ERROR, E_USER_WARNING, E_USER_NOTICE or a combination thereof. set_error_handler(callbeck functionName[,user_error_type]); //Set a callback function for trigger_error() to handle errors, including errors thrown by the system and errors triggered by the user using the trigger_error() function.

Optional parameter user_error_type: If this parameter is set, the callback function can be triggered only when the error type thrown by trigger_error matches the definition range of user_error_type. This value is set similarly to the error_reporting() function.

First parameter (callbeck functionName): A function name. The function can have 5 parameters, of which the first 2 are required, in order: The user_error_type that trigger_error throws, the errorMsg that trigger_error throws, the absolute path of the file that throws the error, the line number that throws the error, and the context when the error is thrown (an array that contains everything in the scope where trigger_error() is located. variables, functions, classes and other data) Return value of the callback function: If false is returned, the system error handling mechanism will continue to throw the error, and return true or no return value to eliminate the error. Errors triggered by trigger_error() will not be caught by try-catch exception catching statements.