The above code will get an error like this:
Fatal Error: uncaught exception ' exception ' with message
' Value must is 1 or below ' in c:webfoldertest.php:6< C2/>stack Trace: #0 c:webfoldertest.php ():
c:webfoldertest.php6
Try, throw and catch
Grab-This is a "C Atch" block retrieves an exception and creates an object that contains exception information
You can try to trigger an exception-valid code:
<?php
//create function with a exception
function Checknum ($number)
{
if ($number >1)
{
throw new Exception ("Value must be 1 or below");
}
return true;
}
Trigger exception in a ' try ' block
try
{
checknum (2);
If the exception is thrown, this text won't be shown
echo ' If you are here, the number is 1 or below ';
//catch Exception
catch (Exception $e)
{
echo ' message: '. $e->getmessage ();
>
The above code will get an error like this:
Message:value must be 1 or below
For example, explain:
The above code throws an exception, capturing it:
The Checknum () function is created. It will check if the number is greater than 1. If so, an exception
The Checknum () function is called a "try" block
The only exception inside the Checknum () function is to throw
Retrives the exception in the catch block and create an object (English) containing exception information
Exception to the error message is the Echo appeal $ e-commerce "getMessage () exception from the object
However, there is a way in which the "every throw must have a catch" rule is to set a top level exception handler to handle the bug slip through the slip.
-------------------------------------------------- ------------------------------
Create a custom exception handling class
Creating a custom exception handler is fairly straightforward. We just create a special class of features that can be said to be an exception when it happens in PHP.
The class must have an extended exception class.
The custom exception handling class inherits the property from the PHP exception handling class, and you can add custom functions to it.
Let's create an exception category:
<?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 The email is not valid
throw new Customexception ($email);
}
catch (customexception $e)
{
//display custom message
echo $e->errormessage ();
}
? >
The new category is an addition to the old exception class ErrorMessage () function. Since this is an old class, it inherits the attributes and methods from the old class, we can use the first class method except the exception like return occurrences () and GetFile () and GetMessage ().
For example, explain:
The above code throws an exception, which captures the custom exception class:
The Customexception () creates a first-class extended old exception class. In this way, it inherits all the methods and attributes from the old exception class
The ErrorMessage () function is created. This function returns an error message if the e-mail address is invalid
The dollar's email variable is set to a string, not a valid e-mail address
"Try" to block execution and exceptions, the e-mail address is invalid
An exception to the catch in the Catch block and displays an error message
-------------------------------------------------- ------------------------------
More exceptions
It is possible that the script uses multiple exceptions to check multiple conditions.
You can use something like. Other blocks, a switch, or nest multiple exceptions. These exceptions can use different exception classes and return different error messages:
<?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 ();
}
? >
For example, explain:
The above code tests two conditions and throws an exception if any condition is not met:
The Customexception () creates a first-class extended old exception class. In this way, it inherits all the methods and attributes from the old exception class
The ErrorMessage () function is created. This function returns an error message if the e-mail address is invalid
The dollar's email variable is set to a string that is a valid e-mail address, but contains a string "model"
The "Try" block execution and an exception is the primary condition of not throwing
The second condition triggers an exception because the e-mail message contains the string "Role model"
An exception to the catch in the catch block and displays the correct error message
If there is no customexception catch-up, only an exception to the base by-catch, except to be processed there
-------------------------------------------------- ------------------------------
and throw the exception.
Sometimes, when an exception, you might as well handle it differently than the standard way. It is possible to throw an exception for the second time in the "catch" block.
The expected script system error hides the user. System errors may be important to the encoder, but are not of interest to the user. In order for your convenience users to be able to toss the exception with the user-friendly message:
<?php
class Customexception extends Exception
{public
function errormessage ()
{
//error Message
$ERRORMSG = $this->getmessage (). ' are 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 ();
}
? >
For example, explain:
The above code tests if the email address contains a string "role model", if so, except to be thrown again:
The Customexception () creates a first-class extended old exception class. In this way, it inherits all the methods and attributes from the old exception class
The ErrorMessage () function is created. This function returns an error message if the e-mail address is invalid
The dollar's email variable is set to a string that is a valid e-mail address, but contains a string "model"
The "Try" block contains a "try" block that allows it to be removed again
The only exception is to raise the string "role model" from the e-mail message
Exceptions to catches in "catch" blocks and then throw a "customexception"
The "Customexception" is the capture and display of error messages
If the exception is not to grasp the current "try" block, it will seek a catch block of "higher level".
-------------------------------------------------- ------------------------------
Setting top-level exception handling
The Set_exception_handler () function sets a user-defined function to handle all uncaught exceptions.
<?php
function MyException ($exception)
{
echo ' <b>Exception:</b> ', $exception-> GetMessage ();
}
Set_exception_handler (' myexception ');
throw new Exception (' uncaught Exception occurred ');
? >
The output is as follows.
Exception: uncaught Exception occurred
above code not There is a "catch" block. Instead, the high-level throws exception handling.
This feature should be used to capture the uncaught exception. Exceptions to the
Rule
Code may be surrounded in a try block to help catch potential exceptions
each try block or "throw" must have at least one catch
multiple catch can be used to catch exceptions to different classes
Exceptions can be thrown (or thrown back) in a catch block in a try block
A simple rule: if you throw something, you have to catch it.