Foutafhandeling in PHP (Error Handling)

  1. Inleiding
  2. Weergave en interpretatie van PHP fouten
  3. Basis foutafhandeling met die()
  4. Een flexibelere manier: trigger_error()
  5. Foutafhandeling en controle van variabelen
  6. Een eigen foutafhandeling functie met set_error_handler()
  7. Exceptions in PHP 5
  8. Gedetailleerde foutinformatie verkrijgen met exceptions
  9. Uitgebreide foutafhandeling met gebruik van foutcodes
  10. Uitbreiden van de standaard Exception klasse
  11. Slotwoord en referenties
  12. Reacties op deze tutorial

Exceptions in PHP 5

Tot nu toe hebben we enkel eenvoudige voorbeelden van foutafhandeling in PHP bekeken. We hebben gezien hoe die() een script genadeloos om zeep helpt, hoe trigger_error() iets flexibeler is in het geven van een foutmelden en hoe we met set_error_handler() een eigen foutafhandeling functie kunnen gebruiken.

Met de komst van exceptions in PHP 5 hebben we een uiterst krachtige manier van foutafhandeling tot onze beschikking gekregen. Dit mechanisme biedt veel meer flexibiliteit, vooral bij het opvangen van fouten en het weergeven van gedetailleerde foutinformatie.

In de rest van deze tutorial zal ik het gebruik van exceptions in PHP behandelen. Ik zal beginnen met het gebruik van try-throw-catch combinaties om vervolgens verder te gaan met iets complexere voorbeelden zoals het gebruik van error types en het uitbreiden van de Exception klasse. Omdat het gebruik van exceptions berust op het principe van object georiënteerd programmereren, is het voor het vervolg van deze tutorial makkelijk als je daar enige kennis van hebt.

Werken met exceptions
Het eerste dat je in gedachten moet houden bij het werken met exceptions, is dat het geen vervanging is van de interne error handler van PHP. Zo worden alle parse errors en fatale fouten nog steeds als lelijke melding op het scherm gezet. Maar deze fouten zou je in principe alleen bij het debuggen tegenkomen en de eindgebruiker zou ze nooit zien. De fouten die de eindgebruiker ziet zijn namelijk degenen die jij met behulp van exceptions weergeeft.

Laten we kijken naar een eenvoudig voorbeeldje:
Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?php
ini_set('display_errors', 'On');
error_reporting(E_ALL);

function groter_dan_5($int)
{
    if($int <= 5)
    {
        throw new Exception('FOUT: Het getal '.$int.' is niet groter dan 5');
    }
    return true;
}

groter_dan_5(4);
?>

Dit script levert de volgende foutmelding op:
Code
1
2
Fatal error: Uncaught exception 'Exception' with message 'FOUT: Het getal 4 is niet groter dan 5' in C:\wamp\www\test.php:9 
Stack trace: #0 C:\wamp\www\test.php(14): groter_dan_5(4) #1 {main} thrown in C:\wamp\www\test.php on line 9

Zoals we zien is dit een PHP foutmelding van het level E_ERROR. Een fatale fout waarbij het script verder niet uitgevoerd wordt.

Deze foutmelding wordt veroorzaakt omdat we de exception die we 'gegooid' hebben naar PHP niet netjes afgevangen hebben. Het afvangen van exceptions doe je met een try-catch combinatie.
Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php
ini_set('display_errors', 'On');
error_reporting(E_ALL);

function groter_dan_5($int)
{
    if($int <= 5)
    {
        throw new Exception('FOUT: Het getal '.$int.' is niet groter dan 5');
    }
    return true;
}

try
{
    groter_dan_5(4);
}
catch(Exception $e)
{
    echo $e->getMessage();
}
?>

Zoals we zien is de output nu gelijk aan de foutmelding die we gegeven hebben:
Code
1
FOUT: Het getal 4 is niet groter dan 5

Try-catch combinatie
Het gooien van een exception kunnen we op elk willekeurig moment in een script doen, zolang we die exception maar netjes afvangen met een 'catch' blok. We hoeven dus ook niet per se een functie te gebruiken om een exception te kunnen gooien:
Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?php
ini_set('display_errors', 'On');
error_reporting(E_ALL);

$getal = 4;
try
{
    if($getal <= 5)
    {
        throw new Exception('FOUT: Het getal '.$getal.' is niet groter dan 5');
    }
    echo 'Groter dan 5!';
}
catch(Exception $e)
{
    echo $e->getMessage();
}
?>

Ook hier krijgen we weer netjes de foutmelding:
Code
1
FOUT: Het getal 4 is niet groter dan 5

Zoals je ziet wordt nadat er een exception gegooid is, de rest van het try block niet meer uitgevoerd. In bovenstaand voorbeeld is het dus ook niet nodig om de echo in een else statement te zetten. Verander de waarde van $getal maar eens naar bijvoorbeeld 6 en bekijk de output van het script.

Gebruik van set_exception_handler()
Een andere manier om die lelijke foutmelding te voorkomen, is het gebruik van een eigen exception handler. Net als met set_error_handler() kunnen we nu de functie set_exception_handler() gebruiken:
Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?php
ini_set('display_errors', 'On');
error_reporting(E_ALL);

function myExceptionHandler($e)
{
    echo 'FOUT: Er is een exception niet opgevangen.<br />';
    echo 'Melding: '.$e->getMessage();
}

set_exception_handler('myExceptionHandler');

$getal = 4;
if($getal <= 5)
{
    throw new Exception('FOUT: Het getal '.$getal.' is niet groter dan 5');
}
echo 'Groter dan 5!';
?>

De output is nu als volgt:
Code
1
2
FOUT: Er is een exception niet opgevangen.
Melding: FOUT: Het getal 4 is niet groter dan 5

Het grote voordeel van de try-catch combinatie is echter dat je zelf kunt bepalen wanneer je een fout wilt afhandelen. Als een exception gegooid wordt en hij wordt nergens afgevangen, dan wordt direct de exception handler functie uitgevoerd en de rest van het script onderbroken.

Als je echter netjes met een catch blok de exception afvangt, loopt het script gewoon netjes door. Het afvangen van de fout zou bij wijze van spreken pas honderden regels code later gebeuren, zonder dat de rest van het script daar hinder van ondervindt.

Vorige Volgende