Sprachreferenz
PHP Manual

Ausnahmebehandlung

PHP 5 hat ein Exceptionmodell ähnlich dem anderer Programmiersprachen. Eine Exception kann in PHP geworfen(throw) und abgefangen (catch) werden. Um das Fangen potentieller Exceptions zu ermöglichen, sollte der jeweilige Code kann von einem try-Block umschlossen werden. Jeder try-Block muss mindestens einen zugehörigen catch Block besitzen. Mehrere catch-Blöcke können verwendet werden, um verschiedene Klassen von Exceptions abzufangen. Die normale Programmausführung (wenn keine Exception innerhalb des try-Blockes geworfen wird oder kein zur Klasse der Exception passendes catch vorhanden ist) wird nach dem letzten in Folge definierten catch-Block fortgesetzt. Exceptions können innerhalb eines catch-Blockes geworfen werden.

Wenn eine Exception geworfen wird, wird der Programmcode hinter der auslösenden Anweisung nicht ausgeführt, und PHP versucht, den ersten passenden catch-Block zu finden. Falls eine Exception nicht abgefangen wird, wird ein fataler Fehler mit einer "Uncaught Exception ..."-Nachricht ausgegeben, wenn nicht eine Behandlung mittels set_exception_handler() definiert wurde.

Beispiel #1 Eine Exception werfen

<?php
function inverse($x) {
    if (!
$x) {
       throw new 
Exception('Division durch Null.');
    }
    else return 
1/$x;
}

try {
    echo 
inverse(5) . "\n";
    echo 
inverse(0) . "\n";
} catch (
Exception $e) {
    echo 
'Exception abgefangen: ',  $e->getMessage(), "\n";
}

// Ausführung fortsetzen
echo 'Hallo Welt';
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

0.2
Exception abgefangen: Division durch Null
Hallo Welt

Beispiel #2 Verschachtelte Exceptions

<?php

class MyException extends Exception { }

class 
Test {
    public function 
testing() {
        try {
            try {
                throw new 
MyException('foo!');
            } catch (
MyException $e) {
                
/* weiterwerfen der Exception */
                
throw $e;
            }
        } catch (
Exception $e) {
            
var_dump($e->getMessage());
        }
    }
}

$foo = new Test;
$foo->testing();

?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

string(4) "foo!"

Exceptions erweitern

Eine benutzerdefinierte Exceptionklasse kann durch Ableitung von der eingebauten Exceptionklasse erstellt werden. Die unten angegebenen Methoden und Eigenschaften zeigen, was innerhalb der Kindklasse von der eingebauten Exceptionklasse verfügbar ist.

Beispiel #3 Die eingebaute Exceptionklasse

<?php
class Exception
{
    protected 
$message 'Unknown exception';   // Exceptionmitteilung
    
protected $code 0;                        // Benutzerdefinierte Fehlernummer
    
protected $file;                            // Quelldateiname der Exception
    
protected $line;                            // Quelldateizeile der Exception

    
function __construct($message null$code 0);

    final function 
getMessage();                // Mitteilung der Exception
    
final function getCode();                   // Fehlercode der Exception
    
final function getFile();                   // Quelldateiname
    
final function getLine();                   // Quelldateizeile
    
final function getTrace();                  // Array zum Rückverfolgen
    
final function getTraceAsString();          // Formatierter String der
                                                // Rückverfolgung

    /* Überschreibbar */
    
function __toString();                       // Formatierter String für
                                                 // Ausgabe
}
?>

Wenn eine Klasse die eingebaute Exceptionklasse erweitert und den Konstruktor neu definiert, ist es dringend empfohlen, dass der Konstruktor der Klasse parent::__construct() aufruft, um sicherzustellen, dass alle verfügbaren Daten korrekt zugewiesen wurden. Die __toString()-Methode kann überschrieben werden, um eine maßgeschneiderte Ausgabe anzubieten, wenn das Objekt durch eine Zeichenkette repräsentiert werden soll.

Beispiel #4 Die Exceptionklasse erweitern

<?php
/**
 * Eine maßgeschneiderte Exceptionklasse definieren
 */
class MyException extends Exception
{
    
// Die Exceptionmitteilung neu definieren, damit diese nicht optional ist
    
public function __construct($message$code 0) {
        
// etwas Code

        // sicherstellen, dass alles korrekt zugewiesen wird
        
parent::__construct($message$code);
    }

    
// maßgeschneiderte Stringdarstellung des Objektes
    
public function __toString() {
        return 
__CLASS__ ": [{$this->code}]: {$this->message}\n";
    }

    public function 
customFunction() {
        echo 
"Eine eigene Funktion dieses Exceptiontyps\n";
    }
}


/**
 * Erzeuge eine Klasse, um die Exception zu testen
 */
class TestException
{
    public 
$var;

    const 
THROW_NONE    0;
    const 
THROW_CUSTOM  1;
    const 
THROW_DEFAULT 2;

    function 
__construct($avalue self::THROW_NONE) {

        switch (
$avalue) {
            case 
self::THROW_CUSTOM:
                
// eigene Exception werfen
                
throw new MyException('1 ist ein ungültiger Parameter'5);
                break;

            case 
self::THROW_DEFAULT:
                
// Vorgabe werfen
                
throw new Exception('2 ist kein zugelassener Parameter'6);
                break;

            default:
                
// Keine Exception, das Objekt wird erzeugt
                
$this->var $avalue;
                break;
        }
    }
}


// Beispiel 1
try {
    
$o = new TestException(TestException::THROW_CUSTOM);
} catch (
MyException $e) {      // Wird gefangen
    
echo "Meine Exception gefangen\n"$e;
    
$e->customFunction();
} catch (
Exception $e) {        // Übersprungen
    
echo "Standardexception gefangen\n"$e;
}

// Ausführung fortsetzen
var_dump($o);
echo 
"\n\n";


// Beispiel 2
try {
    
$o = new TestException(TestException::THROW_DEFAULT);
} catch (
MyException $e) {      // Dieser Typ passt nicht
    
echo "Meine Exception gefangen\n"$e;
    
$e->customFunction();
} catch (
Exception $e) {        // Wird gefangen
    
echo "Standardexception gefangen\n"$e;
}

// Ausführung fortsetzen
var_dump($o);
echo 
"\n\n";


// Beispiel 3
try {
    
$o = new TestException(TestException::THROW_CUSTOM);
} catch (
Exception $e) {        // Wird gefangen
    
echo "Standardexception gefangen\n"$e;
}

// Ausführung fortsetzen
var_dump($o);
echo 
"\n\n";


// Beispiel 4
try {
    
$o = new TestException();
} catch (
Exception $e) {        // Übersprungen, keine Exception ausgelöst
    
echo "Standardexception gefangen\n"$e;
}

// Ausführung fortsetzen
var_dump($o);
echo 
"\n\n";
?>

Sprachreferenz
PHP Manual