Exception handling in PHP ~ DPLW

What is an exception?
An exception is an event that occurs during the execution of a program and requires controlled execution of a block of code outside the normal flow of execution

Exception handling is a very powerful tool when performing a management situation. The first thing to understand is that an exception is not an error. It's a situation that is experienced and a block of code that can not handle.

Why should I use?
Proper exception handling can make your code more reliable save you headaches.

When I throw an exception when an error?
Depends somewhat on the politics of project you're working on, and tastes of each developer. As with the names of the variables, it is best to arrive at a sort of standard within each team.

In general, if we are working on a senior class of an application and very attached to it, the best option may be to report the error using the error handling of the application itself, and try to control it in this place.

If instead we are working on a class of low-level, decoupled from the application you are working and capable of being reused, it is best to throw an exception and let the class try to capture up to inform the user.

How to throw an exception?
An exception is thrown through the reserved word Thrown, we see an example.

< ?php function foo(){ throw new Exception (' Upps !!'); } foo(); // PHP Fatal error: Uncaught exception 'Exception' with message ' Upps !!' <? Php function foo () {throw new Exception ('Upps !!');} foo () / / PHP Fatal error: Uncaught exception' Exception 'with message' Upps! '

So what?
When an exception is thrown PHP try to find a catch {} block capable of capturing, if none are found then the execution will stop and issue a PHP fatal error with the message "Uncaught Exception ...".

To "capture" an exception code must be within a try {} and must have at least one catch {} block. Here is an example.

< ?php <? Phpfunction foo() { function foo () { try { try { throw new Exception(' Upps !!'); throw new Exception ('Upps !!'); } catch (Exception $e) { } Catch (Exception $ e) { // .. / / .. } }} } foo(); foo ();

In this second example the program execution is not interrupted even though it has launched an exception.

Here's another example with multiple catch blocks

< ?php <? Phpfunction foo() { function foo () { try { try { throw new Exception(' Upps !!'); throw new Exception ('Upps !!'); } catch (ErrorException $e) { } Catch (ErrorException $ e) { // este bloque no se ejecuta, no coincide el tipo de excepción / / This block is not executed, does not match the type of exception echo 'ErrorException' . echo 'ErrorException'. $e->getMessage(); $ E-> getMessage (); } catch (Exception $e) { } Catch (Exception $ e) { // este bloque captura la excepción / / This block catches the exception echo 'Exception' . echo 'Exception'. $e->getMessage(); $ E-> getMessage (); } }} } foo(); foo ();

Methods of an exception.
An exception is an object after all, then the methods we have available:

getMessage () returns the exeption message.
getCode () returns the error code.
getFile () returns the name of the file that threw the exception.
getLine () returns the line of the file that threw the exception.
getTrace () returns the cell array format ejeción.
getTraceAsString () returns the stack ejeción format string.
You can find the complete reference on php official site.

Exception Handling
Thanks to set_exception_handler () can handle exceptions not caught by try / cacth.

Thanks to this feature of PHP, you can set to do when an exception occurs, such as:

Generate a log.
Show an error message in a controlled manner.
Send complete information to system administrators so they can debug it.
Here is an example for set_exception_handler:

< ?php <? Php/* / * * recupera información de la * Retrieves information from the * maquina en la que se está efecutando * Machine on which it is efecutando * * * @return string $info * @ Return string $ info */ * / function getInfoMachine() { /* ... getInfoMachine function () {/ * ... */ * /} } /* / * * recupera información de la * Retrieves information from the * variables, $_POST, $_GET, $_SESSION * Variables, $ _POST, $ _GET, $ _SESSION * * * @return string $info * @ Return string $ info */ * / function getInfoEnviroment() { /* ... getInfoEnviroment function () {/ * ... */ * /} } /* / * * recupera información del usuario que * Retrieves user information * esta ejecutando el proceso, en una aplicación * Process is running in an application * con gestión de usuarios. * With user management. * * * @return string $info * @ Return string $ info */ * / function getInfoUser() { /* ... getInfoUser function () {/ * ... */ * /} } /* / * * recupera información de la excepción * Retrieves exception information * * * @param Exception $e * @ Param Exception $ e * @return string $info * @ Return string $ info */ * / function getInfoException(Exception $e) { /* ... getInfoException function (Exception $ e) {/ * ... */ * /} } /* / * * envia informacion a los administradores del sistema * Send information to system administrators * * * @param Exception $e * @ Param Exception $ e * @return true or false * @ Return true or false */ * / function exception_handle(Excepion $e) { exception_handle function (Excepion $ e) { $text = getInfoMachine() . $ Text = getInfoMachine (). getInfoEnviroment() . getInfoEnviroment (). getInfoUser() . getInfoUser (). getInfoException($e); getInfoException ($ e); mail($admins, $e->getMessage(), $message); mail ($ admins, $ e-> getMessage (), $ message);} } set_exception_handler('exception_handler'); set_exception_handler ('exception_handler');

Creating your own exceptions
Why would we want to create a new type of expceción? Very easy to contemplate specific situations, for example if I am making a library that performs image processing, I can want to add extra information to the exception concerning the processing of images.

< ?php <? Phpclass MyException extends Exception {/* ... MyException class extends Exception {/ * ... */} * /}

Cases PROFESSIONALS
The following are some cases that we know PROFESSIONALS.

Errors
A typical error when dealing with exceptions, and no experience, is to skip blocks of code that needed to catch exceptions, we see an example.

< ?php <? Phpfunction foo() { function foo () { DB::query('LOCK TABLES `a`, `b` WRITE'); DB:: query ('LOCK TABLES `a`, `b` WRITE'); try { try { /* operaciones SQL */ / * SQL operations * / } catch (Exception $e) { } Catch (Exception $ e) { /* operaciones SQL */ / * SQL operations * / } } DB::query('UNLOCK TABLES'); DB:: query ('UNLOCK TABLES');} }

In this example we see how the code that unlocks the tables, is outside the catch block, so if an exception occurs the tables will be blocked. Therefore, the catch code must deal with free tables.

< ?php <? Phpfunction foo() { function foo () { DB::query('LOCK TABLES `a`, `b` WRITE'); DB:: query ('LOCK TABLES `a`, `b` WRITE'); try { try { /* operaciones SQL */ / * SQL operations * / } catch (Exception $e) { } Catch (Exception $ e) { /* operaciones SQL */ / * SQL operations * / DB::query('UNLOCK TABLES'); DB:: query ('UNLOCK TABLES'); } } DB::query('UNLOCK TABLES'); DB:: query ('UNLOCK TABLES');} }

Reviving an exception.
In some situations I can will relaunch an exception, if for example I want to execute a block of code to occur, but the upper classes delegate ultimate control of it. Using the same example of the previous block.

< ?php <? Phpfunction foo() { function foo () { DB::query('LOCK TABLES `a`, `b` WRITE'); DB:: query ('LOCK TABLES `a`, `b` WRITE'); try { try { /* operaciones SQL */ / * SQL operations * / } catch (Exception $e) { } Catch (Exception $ e) { /* operaciones SQL */ / * SQL operations * / DB::query('UNLOCK TABLES'); DB:: query ('UNLOCK TABLES'); throw $e; throw $ e; } } DB::query('UNLOCK TABLES'); DB:: query ('UNLOCK TABLES');} }

DPLW

Nov 14, 2011

Exception handling in PHP

0 comments:

Post a Comment

Subscribe via email

Popular Posts

Recent Posts

Blog Archive

Download