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   if (condicion_a_controlar)
 5      throw new Exception('Mensaxe a enviar',1);   // Provocamos unha excepción. O control pasa a sección catch. Podemos enviar un texto e un dato numérico a sección catch (non é obrigatorio)
 6     
 7 
 8 }
 9 catch (Excepcion $e){
10   // Sentenzas a executar en caso de lanzarse a excepción
11 
12 }

Liña 5: En base a controlar algunha condición, podemos provocar unha excepción. Poderíamos lanzar a excepción se enviar nada á sección catch (throw Exception()), ou podemos enviar soamente un texto (throw Exception('Mensaxe a enviar')).
Liña 9: 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   if (condicion_a_controlar)
 5      throw new Exception('Mensaxe a enviar');   
 6 
 7 }
 8 catch (Excepcion $e){
 9   // Sentenzas a executar en caso de lanzarse a excepción
10 
11 }
12 finally{
13   // Sentenzas que sempre se executan
14 }

Capturando os erros da funcións internas de PHP

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          ?>

Liñas 2-4: Definimos unha función que vai 'capturar' os erros que poidan lanzar as funcións de PHP, lanzando unha excepción da clase Exception que será capturada polo bloque catch (Exception $ex).

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.