How PHP throws Exception handling errors

The first thing to know is what is a PHP exception?

An exception (Exception) is used to change the normal flow of a script when a specified error occurs.
PHP 5 provides a new object-oriented error-handling approach.
Exception handling is used to change the normal flow of a script when a specified error (exception) condition occurs. This condition is called an exception.

When an exception is triggered, it usually occurs:

Current code state is saved
Code execution is switched to a predefined exception handler function
Depending on the situation, the processor may restart execution of the code from the saved code State, terminate the script execution, or continue the script from another location in the code
We will show different error handling methods:

Basic use of exceptions
Creating a custom exception handler
Multiple exceptions
Throwing Exceptions again
To set the top-level exception handler
Basic use of exceptions
When the exception is thrown, the subsequent code does not continue, and PHP tries to find a matching "catch" code block.

If the exception is not captured and does not use Set_exception_handler () for the appropriate processing, a serious error (fatal error) occurs, and an error message that outputs "uncaught exception" (no exception is caught) is printed.

Let's try to throw an exception without capturing it:
Copy CodeThe code is as follows:
<?php
Create function with an exceptionfunction
Checknum ($number) {
if ($number >1) {
throw new Exception ("Value must be 1 or below");
return true;
}
Trigger
Exceptionchecknum (2);
?>

The above code will get an error similar to this:

Fatal error:uncaught Exception ' exception ' with message ' Value must is 1 or below ' in C:\webfolder\test.php:6 Stack trace : #0 C:\webfolder\test.php (): Checknum #1 {main} thrown in C:\webfolder\test.php on line 6
Try, throw and catch
To avoid the error in the example above, we need to create the appropriate code to handle the exception.

The processing handler should include:

Try-The function that uses the exception should be in the "try" code block. If no exception is fired, the code continues to execute as usual. However, if the exception is triggered, an exception is thrown.
Throw-Here's how to trigger an exception. Each "throw" must correspond to at least one "catch"
Catch-"catch" blocks catch exceptions and create an object that contains exception information
Let's trigger an exception:

<?php//Create function functions that can throw an exception Checknum ($number) {if ($number >1) {throw new Exception ("Value must be 1 or below");} r Eturn true; }//in the "try" block of code to trigger the exception try {checknum (2);//if the exception is thrown, this text won't be shown echo ' If Number is 1 or below '; }//catch Exception catch (Exception $e) {echo ' message: '. $e->getmessage (); >
The code above will get an error like this:

Message:value must be 1 or below
Example Explanation:
The code above throws an exception and captures it:

Create the Checknum () function. It detects if the number is greater than 1. If it is, an exception is thrown.
Call the Checknum () function in the "Try" code block.
The exception in the Checknum () function is thrown
The catch code block receives the exception and creates an object ($e) that contains exception information.
Output an error message from this exception by calling $e->getmessage () from this exception object
However, to follow the "each throw must correspond to a catch" principle, you can set up a top-level exception handler to handle the missing error.
To create a custom Exception class
Creating a custom exception handler is simple. We simply created a special class that called its function when an exception occurred in PHP. The class must be an extension of the exception class.

This custom exception class inherits all the properties of the PHP exception class, and you can add custom functions to it.

We started creating the exception class:
Copy CodeThe code is as follows:
<?php
Class Customexception extends Exception {
Public Function errormessage () {
Error message
$ERRORMSG = ' Error on line '. $this->getline (). $this->getfile (). ': <b> '. $this->getmessage (). ' </b> is not a valid e-mail address '; return $ERRORMSG;
}
}
$email = "someone@example...com"; try {
Check if
if (Filter_var ($email, filter_validate_email) = = FALSE) {
Throw exception if email is not valid throw
New Customexception ($email);
}
}catch (customexception $e)
{
Display custom Message
echo $e->errormessage ();
}?>

This new class is a copy of the old exception class, plus the ErrorMessage () function. Because it is a copy of the old class, it inherits properties and methods from the old class, and we can use the methods of the exception class, such as Getline (), GetFile (), and GetMessage ().

Example Explanation:
The above code throws an exception and captures it through a custom exception class:

The Customexception () class is created as an extension of the old exception class. So it inherits all the properties and methods of the old class.
Create the ErrorMessage () function. If the e-mail address is not valid, the function returns an error message
Set the $email variable to an illegal e-mail address string
Executes a "Try" code block that throws an exception because the e-mail address is illegal
Catch code block catches an exception and displays an error message
Multiple exceptions
You can use multiple exceptions for a script to detect multiple situations.

You can use multiple if.. else code block, or a switch code block, or nested multiple exceptions. These exceptions can use different exception classes and return different error messages:
Copy CodeThe code is as follows:
<?php
Class Customexception extends Exception{public function errormessage () {
Error
message$errormsg = ' Error on line '. $this->getline (). $this->getfile (). ': <b> '. $this->getmessage ( ).' </b> is not a valid e-mail address ';
return $ERRORMSG;
}
}
$email = "someone@example.com"; try {
Check if
if (Filter_var ($email, filter_validate_email) = = FALSE) {
Throw exception if email is not valid throw new
Customexception ($email);
}
Check for ' example ' in mail address
if (Strpos ($email, "example")!== FALSE) {throw new Exception ("$email is a example e-mail");} catch (Customexception $e) {echo $e->errormessage ();} catch (Exception $e) {echo $e->getmessage ();}? >

Example Explanation:
The code above tests two conditions and throws an exception if any of the conditions are not true:

The Customexception () class is created as an extension of the old exception class. So it inherits all the properties and methods of the old class.
Create the ErrorMessage () function. If the e-mail address is not valid, the function returns an error message.
Executes the "Try" code block, which, under the first condition, does not throw an exception.
Because e-mail contains the string "Example", the second condition triggers an exception.
The catch code block catches the exception and displays the appropriate error message
If Customexception is not captured, the base exception is tightly captured, where the exception is handled.
Throwing Exceptions again
Sometimes, when an exception is thrown, you may want to handle it in a different way from the standard. You can throw an exception again in a "catch" code block.

The script should hide the system error from the user. System errors may be important to programmers, but users are not interested in them. To make the user easier to use, you can throw an exception with a message that is friendly to the user again:
Copy CodeThe code is as follows:
<?php
Class Customexception extends Exception {public Function errormessage () {
Error message
$ERRORMSG = $this->getmessage (). ' is not a valid e-mail address. ' return $ERRORMSG; }} $email = "someone@example.com"; try {try {
Check for ' example ' in mail address
if (Strpos ($email, "example")!== FALSE) {
Throw exception if email is not valid throw new
Exception ($email); } catch (Exception $e) {
Re-throw exception throw new
Customexception ($email); }}catch (Customexception $e) {
Display custom Message
echo $e->errormessage (); }
?>

Example Explanation:
The code above detects if the string "example" is contained in the mail address. If it does, throw the exception again:

The Customexception () class is created as an extension of the old exception class. So it inherits all the properties and methods of the old class.
Create the ErrorMessage () function. If the e-mail address is not valid, the function returns an error message.
Set the $email variable to a valid mail address, but contain the string "example".
The "Try" code block contains another "try" block of code so that the exception can be thrown again.
An exception is triggered because the e-mail contains the string "example".
Catch catches the exception and throws "Customexception" again.
"Customexception" is captured and an error message is displayed.
If the exception is not captured in its current "try" block of code, it looks for a catch code block at a higher level.
To set the top-level exception handler (top level Exception Handler)
The Set_exception_handler () function sets up a user-defined function that handles all exceptions that are not caught.
Copy CodeThe code is as follows:
<?php
function MyException ($exception) {
echo "<b>Exception:</b>", $exception->getmessage ();
}
Set_exception_handler (' myexception ');
throw new Exception (' uncaught Exception occurred ');
?>

The output of the above code should look like this:

Exception:uncaught Exception occurred
In the above code, there is no "catch" code block, but a top-level exception handler is triggered. You should use this function to catch any exceptions that are not caught.
Rules for exceptions
Code that requires exception handling should be placed inside the try code block to catch potential exceptions.
Each try or throw code block must have at least one corresponding catch code block.
Multiple catch blocks can be used to catch different kinds of exceptions.
You can throw a (re-thrown) exception again in a catch code block within the try code block.
In short: If an exception is thrown, it must be caught.