Summary of PHP exception handling and error handling methods

 $a = fopen('test.txt','r');
 //The file is opened without judging it. If the file does not exist, an error will be reported
?> ;

Correct way to write:

 if(file_exists('test.txt')){
 $f=fopen('test.txt','r');
 //Close after use
 fclose( $f);
 }
?>

1. Three ways to handle PHP errors Method 1, simple die() statement; Equivalent to exit(); example:

if(!file_exists('aa.txt')){
 die('File does not exist');
} else {
 //Perform operation
}
//If above die() is triggered, then the echo connection here will not be executed
echo 'ok';

Concise writing:

file_exits('aaa.txt') or die('File does not exist');
echo 'ok';

Method 2, custom errors and error triggers

1. Error handler (custom error, generally used for syntax error handling) Create a custom error function (handler) that must be able to handle at least two parameters (error_level and errormessage), but can accept up to five parameters (error_file, error_line, error_context) grammar: function error_function($error_level,$error_message,$error_file,$error_line,$error_context) //After creation, you need to rewrite the set_error_handler(); function set_error_handler(‘error_function’,E_WARNING); //Here error_function corresponds to the custom handler name created above, and the second parameter is the error level using the custom error handler; Error reporting level (just understand it)

These error reporting levels are the different types of errors that error handlers are designed to handle: Value Constant Description 2 E_WARNING Nonfatal run-time error. Do not pause script execution. 8 E_NOTICE Run-time notifications.

Script discovery errors may occur, but they may also occur while the script is running normally. 256 E_USER_ERROR Fatal user-generated error. This is similar to E_ERROR set by the programmer using the PHP function trigger_error(). 512 E_USER_WARNING Non-fatal user-generated warning. This is similar to the E_WARNING set by the programmer using the PHP function trigger_error(). 1024 E_USER_NOTICE User-generated notification. This is similar to E_NOTICE set by the programmer using the PHP function trigger_error(). 4096 E_RECOVERABLE_ERROR Trapable fatal error. Like E_ERROR, but can be caught by a user-defined handler. (see set_error_handler()) 8191 E_ALL All errors and warnings except level E_STRICT. (In PHP 6.0, E_STRICT is part of E_ALL)

2. Error trigger (generally used to handle logical errors) Requirement: For example, if you want to receive an age, if the number is greater than 120, it is considered an error. Traditional method:

if($age>120){
echo 'Age Error';exit();
}
 Use trigger:
 if($age>120){
 //trigger_error ('Error message'[,'Error level']);The error level here is optional and is used to define the level of the error
 //User-defined levels include the following three types: E_USER_WARNING, E_USER_ERROR, E_USER_NOTICE
 trigger_error('Age Error');//This is the default error handling method of the calling system. We can also use a custom processor
 }
 //Custom processor, the same as above
 function myerror($error_level,$error_message){
 echo 'error text';
 }
 //At the same time, the system default processing function needs to be changed

set_error_handler('myerror',E_USER_WARNING);//Same as above, the first parameter is the name of the custom function, and the second is the error level [The error levels here are usually the following three :E_USER_WARNING, E_USER_ERROR, E_USER_NOTICE] //Now you can use trigger_error to use a custom error handling function Practice questions:

 date_default_timezone_set('PRC');
 function myerror($error_level,$error_message){
 $info= "Error number: $error_leveln";
 $info.= "Error message: $error_messagen";
 $info.= 'Occurrence time:'.date('Y-m-d H:i:s');
 $filename='aa.txt';
 if(!$fp=fopen($filename,' a')){
 'Failed to create file'.$filename.';
 }
 if(is_writeable($filename)){
 if(!fwrite($fp,$info)){
 echo 'Write file failed';
 } else {
 echo 'Error message recorded successfully';
 }
 fclose($fp);
 } else {
 echo 'File'.$filename.'not writable';
 }
 exit() ;
 }
 set_error_handler('myerror',E_WARNING);
 $fp=fopen('aaa.txt','r');
?>

Method 3, error log By default, according to the error_log configuration in php.ini, php sends error records to the server's error recording system or file. Error records can be sent to a file or remote destination by using the error_log() function; grammar: error_log(error[,type,destination,headers])

The type part generally uses 3, which means appending error information to the end of the file without overwriting the original content. destination represents the destination, that is, the stored file or remote destination For example: error_log(“$error_info”,3,”errors.txt”);

2. PHP exception handling

1. Basic grammar

try{
//Code that may cause errors or exceptions
//catch Catching Exception is a defined exception class in PHP
} catch(Exception $e){
//Exception handling, method:
//1. Handle it yourself
//2. If you don’t handle it, throw it again
}

2. The processing handler should include: Try – Functions that use exceptions should be inside a “try” block. If no exception is triggered, the code continues execution as usual. But if an exception is triggered, an exception will be thrown. Throw – This specifies how to trigger the exception. Each "throw" must correspond to at least one "catch" Catch – The “catch” block catches the exception and creates an object containing the exception information

Trigger an exception:

 //Create a function that can throw an exception
 function checkNum($number){
 if($number>1){
 throw new Exception("Value must be 1 or below ");
 }
 return true;
 }

//Trigger an exception in the "try" code block
try{
 checkNum(2);
 //If the exception is thrown, then the following line of code will not be Output
 echo 'If you see this, the number is 1 or below';
 }catch(Exception $e){
 //Catch exception
 echo 'Message: ' .$e->getMessage();
 }
 ?>

The above code will report an error like this: Message: Value must be 1 or below

Explanation:

The above code throws an exception and catches it:

Create checkNum() function. It detects whether the number is greater than 1. If so, throw an exception. Call the checkNum() function in the "try" block. Exception in checkNum() function is thrown The "catch" code block receives the exception and creates an object ($e) containing the exception information. Output the error message from this exception by calling $e->getMessage() from this exception object However, in order to follow the principle of "every throw must correspond to a catch", you can set up a top-level exception handler to handle missed errors.

set_exception_handler() function can set a user-defined function that handles all uncaught exceptions

//Set a top exception handler
function myexception($e){
　 echo 'this is top exception';
} //Modify the default exception handling

set_exception_handler("myexception");

try{
$i=5;
if($i<10){
throw new exception('$i must greater than 10');
}
}catch(Exception $e){
//Handle exceptions
echo $e->getMessage().'';
//Do not handle exceptions and continue to throw
 throw new exception('errorinfo'); //You can also use throw $e to retain the original error message;
}

Create a custom exception class

class customException extends Exception{
  public function errorMessage(){
  //error message $errorMsg = 'Error on line '.$this->getLine().' in '. $this->getFile().': '.$this->getMessage().' is not a valid E-Mail
 address'; return $errorMsg;
 }
 }

//Use
try{
 Throw new customException('error message');
 }catch(customException $e){
 echo $e->errorMsg();
 }

You can use multiple catches to return error information under different circumstances

 try{
 　$i=5;
 　if($i>0){
 　　throw new customException('error message');//Use a custom exception class to handle
 　　} if($i<- 10){
 　　throw new exception('error2');//Use the system default exception handling
 　}
}catch(customException $e){
 　echo $e->getMessage();
 }catch(Exception $e1) {
 　echo $e1->getMessage();
 }

Rules for using exceptions: 1. Put the code that needs exception handling into the try code block to catch potential exceptions. 2. Each try or throw code block must have at least one corresponding catch code block. 3. Use multiple catch code blocks to catch different types of exceptions. 4. The exception can be re-thrown in the catch code block within the try code.

Remember one sentence: If an exception is thrown, you must catch it.