PHP Control de erros

Excepcións

• Durante o desenvolvemento da aplicación imos atoparnos coa necesidade de controlar os erros que poidan darse nas chamadas ás diferentes funcións.

Isto pode levar a programar cunha estrutura de if - else moi 'anidada', que faga que o código sexa pouco lexible.

• Para evitalo podemos facer uso das EXCEPCIÓNS.

Podemos facer uso delas a partires da versión 5 de PHP.

• A idea é moi simple: En caso de erro imos 'capturar' ou 'lanzar' unha excepción.

Unha excepción é un tipo de erro que pode darse na execución de programas. Normalmente son erros non controlados por nos nas liñas de programación, pero tamén podemos 'provocar' unha excepción enviando un texto e un código.

A sintaxe é moi sinxela:

1 try {
2 
3   // Sentenzas a controlar
4 
5 }
6 catch (Excepcion $e){
7   // Sentenzas a executar en caso de lanzarse a excepción
8 
9 }

• Liña 6: O obxecto $e pertence á clase Excepcion e dispón entre as súas propiedades e métodos:

• $e->getMessage(); // Devolve a mensaxe da excepción
• $e->getCode(); // Devolve o código da excepción

• Cando se produce a excepción, o control do programa vai a sección catch, deixando de executarse o resto de liñas do programa dentro da sección try.

• A partires da versión PHP 5.5 podemos incorporar outra sección: finally.

Dita sección execútase sempre, haia ou non unha excepción e ao final de todo, despois de executar a última sentenza controlada ou despois de executar a sección catch se houbo unha excepción.

 1 try {
 2 
 3   // Sentenzas a controlar
 4 
 5 }
 6 catch (Excepcion $e){
 7   // Sentenzas a executar en caso de lanzarse a excepción
 8 
 9 }
10 finally{
11   // Sentenzas que sempre se executan
12 }

• AVISO: Indicar que no caso de PHP 'tradicional' as funcións PHP non 'lanzan' excepcións, se non que 'avisan' con warnings, errors,...dependendo do nivel de erro a amosar, o cal está indicado na directiva display_error de php.ini.

Nestes casos podemos facer uso da función set_error_handler para 'capturar' os erros.

 1         <?php
 2             set_error_handler(function () {
 3                 throw new Exception('Houbo un erro...');
 4             });
 5 
 6             try{
 7                 $array = array('uno','dos','tres');
 8                 echo $array[10];
 9                 
10             } 
11             catch (Exception $ex) {
12                 echo "Outro erro non controlado";
13                 echo $ex->getMessage(); // Amosará o enviado dende a función --> Houbo un erro...
14             }
15          ?>

Se queremos volver a deixar a xestión de erros como estaba deberemos chamar á función restore_error_handler.

Xerarquía de excepcións

• No control de excepcións temos unha xerarquía de clases que representan diferentes tipos de excepción.

Esta xerarquía ten unha estrutura de herdanza no que o pai de todas elas é a clase Excepcion (a vista na explicación anterior).

Esta clase (a clase Excepcion) ten coma vantaxe que vai poder capturar todas as excepcións que se poidan producir, pero terá como desvantaxe que non imos saber que tipo de excepción foi capturada (podemos ter unha idea polo código da excepción).

• Para 'afinar' máis o tipo de erro que podemos capturar existen outras clases que derivan da clase Exception e que capturan un tipo específico de excepción. Desta forma podemos ou mandar unha mensaxe ao cliente ou ter diferentes sentenzas a executar en caso de producirse diferentes tipos de excepcións.

Imaxe obtida dende https://fossies.org/dox/php-5.2.17/classException.html

• A partires da versións 7 de PHP aparece unha nova xerarquía de clases para capturar erros:

Máis información neste enlace

-- Ángel D. Fernández González -- (2016).