Skip to content

7. Ausnahmen und Fehler

Wenn eine Methode einer Klasse auf einen nicht behebbaren Fehler stößt (Datei existiert nicht, Datenbank nicht verbunden, Netzwerkverbindung unterbrochen), gibt sie keinen Fehler auf einer Konsole (Datei, Datenbank) aus, sondern löst eine Ausnahme aus. Ausnahmen erweitern die Klasse [\Exception]. Neben den Ausnahmen löst auch der interne Betrieb von PHP Fehler aus, deren Basisklasse [\Error] ist. Beide Klassen implementieren die Schnittstelle [\Throwable].

PHP 8 hat die Fehlerbehandlung grundlegend verändert: Viele Situationen, die in PHP 7 nur eine einfache Warnung (und oft ein absurdes Ergebnis) erzeugten, lösen jetzt einen Fehler aus, der abgefangen werden kann. Das werden wir im Verlauf der Beispiele sehen.

7.1. Die Verzeichnisstruktur der Skripte

Die Skripte dieses Kapitels befinden sich im Ordner [scripts-console/exceptions]:

1
2
3
4
5
6
php8-oct-2026/scripts-console/exceptions
├── exceptions-01.php
├── exceptions-02.php
├── ...
├── exceptions-11.php
└── throwables.php

7.2. Die Schnittstelle [\Throwable]

Die Schnittstelle [\Throwable] sieht wie folgt aus (siehe Dokumentation):

interface Throwable extends Stringable
{
    public function getMessage(): string;
    public function getCode(): int;
    public function getFile(): string;
    public function getLine(): int;
    public function getTrace(): array;
    public function getTraceAsString(): string;
    public function getPrevious(): ?Throwable;
    public function __toString(): string;
}

Die Methoden der Schnittstelle haben folgende Aufgaben:

Methode
Zweck
[getMessage]
liefert die Fehlermeldung
[getCode]
liefert den Fehlercode (eine ganze Zahl)
[getFile]
liefert den Namen der Datei, in der das Objekt erzeugt wurde
[getLine]
liefert die Zeilennummer, in der das Objekt erzeugt wurde
[getTrace]
liefert den Funktionsaufrufstapel als Array
[getTraceAsString]
liefert den Aufrufstapel als Zeichenkette
[getPrevious]
liefert das vorherige (gekapselte) Objekt [Throwable] oder [null]
[__toString]
liefert eine Zeichenkettendarstellung des Objekts

Beachten Sie, dass die Schnittstelle [Throwable] die im Kapitel über Klassen behandelte Schnittstelle [Stringable] erweitert. Eine Klasse kann die Schnittstelle [Throwable] nicht direkt implementieren; sie muss von [\Exception] oder [\Error] abgeleitet sein.

7.3. Vordefinierte Ausnahmen und Fehler in PHP 8

Das folgende Skript [throwables.php] zeigt die Baumstruktur der vordefinierten Klassen an, die die Schnittstelle [Throwable] implementieren. Wir verwenden es, um eine exakte Liste – die von PHP 8.5 – zu erhalten, statt sie aus der Dokumentation abzuschreiben. Sie verpassen nichts, wenn Sie nicht versuchen, den Code zu verstehen, der die Reflection-API von PHP verwendet (die Klasse [ReflectionClass] erlaubt es, PHP nach einer Klasse zu befragen: ihrem Namen, ihrer ursprünglichen Erweiterung, ihren Schnittstellen usw.) und eine rekursive Funktion:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter
declare(strict_types=1);

// zeigt den Baum der vordefinierten Klassen an, die die Schnittstelle [Throwable] implementieren
// wir beschränken uns auf die in PHP 8.5 immer vorhandenen Erweiterungen:
// den Kern (Core), die Standardbibliothek, die SPL-Bibliothek, JSON und Random
$extensions = ["Core", "standard", "SPL", "json", "random"];

// die vordefinierten Klassen dieser Erweiterungen, die [Throwable] implementieren
$classes = array_filter(
    get_declared_classes(),
    function (string $class) use ($extensions): bool {
        $reflection = new ReflectionClass($class);
        return $reflection->isInternal()
            && $reflection->implementsInterface(Throwable::class)
            && in_array($reflection->getExtensionName(), $extensions, true);
    }
);
sort($classes);

// rekursive Anzeige der Kindklassen der Klasse [$parent]
function display(?string $parent, array $classes, string $indentation): void
{
    // die direkten Kinder von [$parent]
    $children = array_values(array_filter(
        $classes,
        fn(string $class): bool => (get_parent_class($class) ?: null) === $parent
    ));
    foreach ($children as $i => $child) {
        $last = $i === count($children) - 1;
        print $indentation . ($last ? "└── " : "├── ") . $child . "\n";
        display($child, $classes, $indentation . ($last ? "    " : "│   "));
    }
}

print "Throwable\n";
display(null, $classes, "");

Ergebnisse:

> php throwables.php
Throwable
├── Error
│   ├── ArithmeticError
│   │   └── DivisionByZeroError
│   ├── AssertionError
│   ├── CompileError
│   │   └── ParseError
│   ├── FiberError
│   ├── Random\RandomError
│   │   └── Random\BrokenRandomEngineError
│   ├── TypeError
│   │   └── ArgumentCountError
│   ├── UnhandledMatchError
│   └── ValueError
└── Exception
    ├── ClosedGeneratorException
    ├── ErrorException
    ├── JsonException
    ├── LogicException
    │   ├── BadFunctionCallException
    │   │   └── BadMethodCallException
    │   ├── DomainException
    │   ├── InvalidArgumentException
    │   ├── LengthException
    │   └── OutOfRangeException
    ├── Random\RandomException
    ├── RequestParseBodyException
    └── RuntimeException
        ├── OutOfBoundsException
        ├── OverflowException
        ├── RangeException
        ├── UnderflowException
        └── UnexpectedValueException

Kommentare

  • Zeile 13: Die Funktion [get_declared_classes] liefert eine Liste aller an dieser Stelle bekannten Klassen, ob vordefiniert oder nicht;
  • Zeilen 16–18: Es werden nur vordefinierte (interne) Klassen beibehalten – solche, die die Schnittstelle [Throwable] implementieren und zu Erweiterungen gehören, die in PHP 8.5 immer vorhanden sind (Zeile 9). Andere Erweiterungen bringen eigene Ausnahmen mit (zum Beispiel [PDOException] für den Datenbankzugriff, der uns später begegnen wird);
  • Zeilen 24–36: eine rekursive Funktion, die die direkten Kindklassen der Klasse [$parent] anzeigt, dann die Kinder jeder dieser Klassen usw. Die Funktion [get_parent_class] liefert [false] für eine Klasse ohne Elternklasse: Der Operator [?:] wandelt [false] dann in [null] um;
  • Zeile 29: eine Pfeilfunktion (PHP 7.4), eine Kurzform einer anonymen Funktion, die auf einen Ausdruck reduziert ist;
  • Zeile 39: Wir beginnen mit den Klassen ohne Elternklasse: [Error] und [Exception].

Die Ergebnisse zeigen zwei Familien:

  • die Familie [Exception]: Das sind die Ausnahmen, die von Bibliotheken und Anwendungscode ausgelöst werden. Dazu gehören:
    • [ErrorException], die eine Warnung von PHP in eine Ausnahme umwandelt (wir verwenden sie am Ende des Kapitels);
    • [JsonException] (PHP 7.3), ausgelöst von [json_encode] und [json_decode] mit der Option [JSON_THROW_ON_ERROR];
    • [Random\RandomException] (PHP 8.2), ausgelöst von den Funktionen zur Zufallszahlenerzeugung;
    • die Ausnahmen der SPL-Bibliothek (Standard PHP Library), einer Sammlung von Klassen und Schnittstellen zur Lösung von Problemen, auf die Entwickler häufig stoßen. Sie bilden zwei Unterfamilien:
    • [LogicException] und ihre Ableitungen: Programmierfehler, die sich durch Korrektur des Codes beheben lassen: ungültiges Argument ([InvalidArgumentException]), Wert außerhalb des erwarteten Bereichs ([DomainException]), nicht vorhandene Methode ([BadMethodCallException]) ...;
    • [RuntimeException] und ihre Varianten: Fehler, die sich erst zur Laufzeit erkennen lassen: Index außerhalb der Grenzen ([OutOfBoundsException]), unerwarteter Wert ([UnexpectedValueException]), Kapazität überschritten ([OverflowException]) ...;
  • die Familie [Error]: Das sind Fehler, die von der PHP-Engine selbst ausgelöst werden. Dazu gehören:
    • [TypeError]: Ein Wert hat nicht den erwarteten Typ (Funktionsparameter, typisiertes Attribut, Rückgabewert, Operand eines Operators usw.). Ihre Ableitung [ArgumentCountError] zeigt eine unzureichende Anzahl von Argumenten an;
    • [ValueError] (PHP 8.0): Ein Wert hat den richtigen Typ, aber einen ungültigen Wert (zum Beispiel eine negative Länge oder die Länge null);
    • [ArithmeticError] und ihre Ableitung [DivisionByZeroError]: Fehler bei arithmetischen Operationen;
    • [UnhandledMatchError] (PHP 8.0): Kein Zweig des Ausdrucks [match] passt;
    • [AssertionError]: Die Zusicherung [assert] ist fehlgeschlagen;
    • [CompileError] und ihre Ableitung [ParseError]: Syntaxfehler in einer Datei, die mit [require] oder [include] geladen wird;
    • [FiberError] (PHP 8.1) und [Random\RandomError] (PHP 8.2): Fehler im Zusammenhang mit Fibers und Zufallszahlengeneratoren, die wir nicht verwenden werden.

Die beiden Familien sind nicht miteinander verwandt: Eine Klausel [catch (\Exception $e)] fängt einen Fehler vom Typ [Error] nicht ab. Nur die Schnittstelle [Throwable] verbindet sie.

7.4. Beispiel 1

Das erste Beispiel, [exceptions-01.php], zeigt sowohl eine PHP-Warnung als auch einen Fehler:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter
declare(strict_types=1);

// Anzeige aller Fehler
error_reporting(E_ALL);
ini_set("display_errors", "1");
// Code --------
$var = [];
// unbekannter Schlüssel
print $var["abcd"];
// Division durch null
$var = 7 / 0;
var_dump($var);
// Array mit fester Größe
$array = new \SplFixedArray(5);
$array[1] = 2;
$array[4] = "foo";
// Index außerhalb der Grenzen
$array[5] = 8;

Kommentare

  • Zeile 7: PHP wird angewiesen, alle Fehler zu melden. Der Parameter der Funktion [error_reporting] ist die Fehlerberichtsstufe. Sie ist eine Kombination der folgenden Konstanten (der wichtigsten):
Konstante
Bedeutung
[E_ERROR]
Schwerwiegender Laufzeitfehler: Das Skript wird beendet
[E_WARNING]
Warnung: Das Skript läuft weiter
[E_PARSE]
Syntaxfehler, der beim Kompilieren erkannt wird
[E_NOTICE]
Hinweis: Etwas, das ein Fehler sein könnte
[E_DEPRECATED]
Verwendung einer veralteten Funktion, die in einer künftigen Version entfernt wird
[E_USER_WARNING], [E_USER_NOTICE], [E_USER_DEPRECATED]
Dieselben Stufen, die vom Code mit der Funktion [trigger_error] ausgelöst werden
[E_ALL]
alle Stufen
  • die Konstante [E_STRICT], die seit PHP 8.0 keiner Meldung mehr entspricht, ist seit PHP 8.4 veraltet, ebenso wie die Verwendung der Stufe [E_USER_ERROR] mit [trigger_error]: Um einen schwerwiegenden Fehler zu melden, löst der Code eine Ausnahme aus;
  • Zeile 8: Der Code wird so eingestellt, dass Fehler auf der Konsole angezeigt werden. In der Produktion macht man das Gegenteil: Fehler werden in eine Logdatei geschrieben und nicht angezeigt;
  • Zeile 12: Es wird versucht, auf ein nicht vorhandenes Element des Arrays [$var] zuzugreifen;
  • Zeile 14: Es kommt zu einer Division durch null;
  • Zeile 17: Es wird eine Instanz der Klasse [SplFixedArray] aus der SPL-Bibliothek erzeugt. Mit dieser Klasse lässt sich ein Array fester Größe mit ganzzahligen Indizes erstellen;
  • Zeile 21: Es wird versucht, auf ein nicht vorhandenes Element des Arrays zuzugreifen.

Ergebnisse:

1
2
3
4
5
6
7
8
> php exceptions-01.php

Warning: Undefined array key "abcd" in .../php8-oct-2026/scripts-console/exceptions/exceptions-01.php on line 12

Fatal error: Uncaught DivisionByZeroError: Division by zero in .../php8-oct-2026/scripts-console/exceptions/exceptions-01.php:14
Stack trace:
#0 {main}
  thrown in .../php8-oct-2026/scripts-console/exceptions/exceptions-01.php on line 14

Kommentare zu den Ergebnissen

  • Zeile 3: Der Zugriff auf einen nicht vorhandenen Schlüssel in einem Array löst eine Warnung der Stufe [E_WARNING] aus (in PHP 7 war es ein einfacher Hinweis [E_NOTICE] ). Die Ausführung des Skripts wird dadurch nicht unterbrochen;
  • Zeilen 5–8: In PHP 7 löste die Division einer Zahl durch null eine Warnung [E_WARNING] aus und lieferte den Wert [INF] (unendlich). In PHP 8 löst der Operator [/] einen Fehler vom Typ [DivisionByZeroError] aus. Da dieser nicht abgefangen wird, unterbricht er die Ausführung des Skripts: Es handelt sich um einen schwerwiegenden Fehler (Fatal error: Uncaught...). Die Meldung zeigt den Aufrufstapel (Stack trace) zum Zeitpunkt des Fehlers an;
  • der Code nach der Division wird nicht ausgeführt: Der Versuch, auf einen nicht vorhandenen Index im Array [SplFixedArray] zuzugreifen, findet nicht statt. Das werden wir in den folgenden Beispielen noch einmal sehen.

7.5. Ausnahmen behandeln

Das Skript [exceptions-02.php] zeigt, wie Ausnahmen behandelt werden:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter
declare(strict_types=1);

// wir zeigen alle Fehler an
error_reporting(E_ALL);
ini_set("display_errors", "1");
// wir umgeben den Code mit einem try / catch
try {
    $var = [];
    // unbekannter Schlüssel
    print $var["abcd"];
    // Division durch null
    $var = 7 / 0;
    var_dump($var);
    // Array mit fester Größe
    $array = new \SplFixedArray(5);
    $array[1] = 2;
    $array[4] = "foo";
    // Index außerhalb der Grenzen
    $array[5] = 8;
    // Prüfung
    print "this message will not be displayed\n";
} catch (\Throwable $ex) {
    // \Throwable ist die Schnittstelle, die von allen Fehlern und Exceptions implementiert wird
    // wir zeigen die Exception an
    print "error, message: " . $ex->getMessage() . ", type: " . $ex::class . "\n";
}

Kommentare

  • Das Skript ist das im vorigen Abschnitt vorgestellte. Wir haben jedoch den Code, der Fehler verursachen könnte, nun in eine Struktur [try / catch] eingeschlossen: Wenn der Code in den Zeilen 11–24 eine Ausnahme oder einen Fehler auslöst (wirft), wird dieser von der Klausel [catch] in den Zeilen 25–29 behandelt;
  • Zeile 25: Der Parameter der Klausel [catch] ist der Typ der Ausnahme oder des Fehlers, der behandelt werden soll. Indem wir den Typ [\Throwable] angeben, bei dem es sich um eine Schnittstelle handelt, legen wir fest, dass jede Klasseninstanz behandelt werden soll, die die Schnittstelle [\Throwable] implementiert. Da alle Fehler- und Ausnahmeklassen diese Schnittstelle implementieren, behandelt die Klausel [catch] hier alle Fehler und Ausnahmen;
  • Zeile 15: die Anweisung, die den Fehler auslöst. Sobald eine Ausnahme auftritt, geht die Steuerung an die Klausel [catch] über. Der in [try] folgende Code wird daher nicht ausgeführt;
  • Zeile 28: Die Notation [$ex::class] liefert den Klassennamen des Objekts [$ex].

Ergebnisse:

1
2
3
4
> php exceptions-02.php

Warning: Undefined array key "abcd" in .../php8-oct-2026/scripts-console/exceptions/exceptions-02.php on line 13
error, message: Division by zero, type: DivisionByZeroError

Kommentare zu den Ergebnissen

  • Zeile 3: Wir sehen die Warnung der Stufe [E_WARNING]. Eine Warnung ist keine Ausnahme und wird daher von der Klausel [catch] nicht behandelt. Am Ende dieses Kapitels sehen wir, wie sich Warnungen in Ausnahmen umwandeln lassen;
  • Zeile 4: Die Fehlermeldung wird in der Klausel [catch] geschrieben. Das bedeutet, dass eine von [\Exception] abgeleitete Ausnahme oder ein von [\Error] abgeleiteter Fehler aufgetreten ist. Hier sehen wir, dass es sich um die Klasse [DivisionByZeroError] handelt. Das Skript wurde normal beendet.

7.6. Parameter der Klausel [catch]

Betrachten wir das folgende Skript [exceptions-03.php]:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter
declare(strict_types=1);

// wir zeigen alle Fehler an
error_reporting(E_ALL);
ini_set("display_errors", "1");

// ein Array mit fester Größe
$array = new \SplFixedArray(5);
try {
    // Index außerhalb der Grenzen
    $array[5] = 8;
} catch (\Throwable $ex) {
    // Anzeige der Fehlermeldung
    print "Error 1: " . $ex->getMessage() . " (" . $ex::class . ")\n";
}

try {
    // Index außerhalb der Grenzen
    $array[5] = 8;
} catch (\Exception $ex) {
    // Anzeige der Fehlermeldung
    print "Error 2: " . $ex->getMessage() . "\n";
}

try {
    // Index außerhalb der Grenzen
    $array[5] = 8;
} catch (\RuntimeException $ex) {
    // Anzeige der Fehlermeldung
    print "Error 3: " . $ex->getMessage() . "\n";
}

try {
    // Index außerhalb der Grenzen
    $array[5] = 8;
} catch (\OutOfBoundsException $ex) {
    // Anzeige der Fehlermeldung
    print "Error 4: " . $ex->getMessage() . "\n";
}

try {
    // Division durch 0
    intdiv(5, 0);
} catch (\Throwable $ex) {
    // Anzeige der Fehlermeldung
    print "Error 5: " . $ex->getMessage() . " (" . $ex::class . ")\n";
}

try {
    // Division durch 0
    intdiv(5, 0);
} catch (\DivisionByZeroError $ex) {
    // Anzeige der Fehlermeldung
    print "Error 6: " . $ex->getMessage() . "\n";
}

try {
    // Division durch 0
    intdiv(5, 0);
} catch (\ArithmeticError $ex) {
    // Anzeige der Fehlermeldung
    print "Error 7: " . $ex->getMessage() . "\n";
}

try {
    // Division durch 0
    intdiv(5, 0);
} catch (\Error $ex) {
    // Anzeige der Fehlermeldung
    print "Error 8: " . $ex->getMessage() . "\n";
}

try {
    // Division durch 0
    intdiv(5, 0);
} catch (\Exception $ex) {
    // Anzeige der Fehlermeldung
    print "Error 9: " . $ex->getMessage() . "\n";
}

Kommentare

  • Zeilen 11–41: Vier verschiedene Arten, die Ausnahme zu behandeln, die durch die Verwendung eines falschen Index bei der Klasse [\SplFixedArray] erzeugt wird. Die Ausführung zeigt, dass dieser Fehler eine Ausnahme vom Typ [OutOfBoundsException] auslöst (Zeile 2 der Ergebnisse). Im PHP-7-Kurs (und noch in PHP 8.3) war es eine Ausnahme vom Typ [RuntimeException]. Die Änderung hat bestehenden Code nicht beeinträchtigt, da die Klasse [OutOfBoundsException] von der Klasse [RuntimeException] abgeleitet ist;
    • Zeile 15: behandelt einen Fehler vom Typ [\Throwable]. Das ist zulässig, da der Typ [OutOfBoundsException] vom Typ [\Exception] abgeleitet ist, der die Schnittstelle [\Throwable] implementiert;
    • Zeile 23: behandelt einen Fehler vom Typ [\Exception]. Das ist zulässig, da der Typ [OutOfBoundsException] vom Typ [\Exception] abgeleitet ist;
    • Zeile 31: behandelt einen Fehler vom Typ [\RuntimeException]. Das ist zulässig, da der Typ [OutOfBoundsException] vom Typ [\RuntimeException] abgeleitet ist. Das ist eine gute Wahl: Der Code funktioniert unabhängig von der PHP-Version;
    • Zeile 39: behandelt den genauen Typ der erzeugten Ausnahme;
  • Zeilen 46–81: 5 verschiedene Arten, den Fehler zu behandeln, der von der Funktion [intdiv] erzeugt wird, wenn ihr ein Divisor gleich 0 übergeben wird. Die Funktion [intdiv(int $dividend, int $divisor): int] führt die ganzzahlige Division [$dividend / $divisor] aus. Ist der Divisor null, wird der Fehler [\DivisionByZeroError] ausgelöst;
    • Zeile 47: Jeder Fehler, der die Schnittstelle [\Throwable] implementiert, wird abgefangen. Das ist zulässig;
    • Zeile 55: Der genaue Typ des Fehlers wird abgefangen; dies ist die bevorzugte Methode;
    • Zeile 63: Der Typ [\ArithmeticError] wird abgefangen. Das ist zulässig, da die Klasse [DivisionByZeroError] die Klasse [ArithmeticError] erweitert;
    • Zeile 71: Der Typ [\Error] wird abgefangen. Das ist zulässig, da die Klasse [DivisionByZeroError] von der Klasse [Error] abgeleitet ist;
    • Zeile 79: Der Typ [\Exception] wird abgefangen. Das ist unzulässig, da die Klasse [DivisionByZeroError] in keiner Beziehung zur Klasse [\Exception] steht.

Ergebnisse:

> php exceptions-03.php
Error 1: Index invalid or out of range (OutOfBoundsException)
Error 2: Index invalid or out of range
Error 3: Index invalid or out of range
Error 4: Index invalid or out of range
Error 5: Division by zero (DivisionByZeroError)
Error 6: Division by zero
Error 7: Division by zero
Error 8: Division by zero

Fatal error: Uncaught DivisionByZeroError: Division by zero in .../php8-oct-2026/scripts-console/exceptions/exceptions-03.php:78
Stack trace:
#0 .../php8-oct-2026/scripts-console/exceptions/exceptions-03.php(78): intdiv(5, 0)
#1 {main}
  thrown in .../php8-oct-2026/scripts-console/exceptions/exceptions-03.php on line 78

Die Zeilen 11–15 der Ergebnisse zeigen, dass der Fehler [DivisionByZeroError] von der letzten Klausel [catch (\Exception $ex)] nicht abgefangen wurde: Es handelt sich um einen schwerwiegenden Fehler.

7.7. Die Klausel [finally]

Die Struktur [try / catch] kann ein drittes Element haben und so zu einer Struktur [try / catch / finally] werden. Der Code der Klausel [finally] wird in den folgenden beiden Fällen ausgeführt:

  • Die Klausel [try] löst keine Ausnahme aus. Sie wird dann vollständig ausgeführt, danach geht die Ausführung zur Klausel [finally] über, die ebenfalls vollständig ausgeführt wird;
  • Die Klausel [try] löst eine Ausnahme aus. Sie wird dann bis zur Anweisung ausgeführt, die die Ausnahme auslöst. Danach geht die Ausführung zur Klausel [catch] über, die vollständig ausgeführt wird. Anschließend geht die Ausführung zur Klausel [finally] über, die vollständig ausgeführt wird.

Schließlich wird der Code der Klausel [finally] trotzdem ausgeführt. Dieses Szenario ist im folgenden Fall nützlich:

  • In der Klausel [try] hat der Code Ressourcen belegt (Dateien, Datenbanken, Netzwerkverbindungen, Warteschlangen). Diese Ressourcen sind in der Regel teuer. Sie müssen daher so schnell wie möglich freigegeben (meist „geschlossen“ genannt) werden;
  • Wurden die Ressourcen in [try] belegt, übernimmt [finally] ihre Freigabe. So ist sichergestellt, dass die belegten Ressourcen in jedem Fall (ob ein Fehler auftritt oder nicht) an das System zurückgegeben werden.

Das folgende Skript [exceptions-04.php] zeigt, wie die Klausel [finally] in verschiedenen Situationen funktioniert:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter
declare(strict_types=1);

// wir erzeugen eine Exception-Instanz
$e = new \Exception("Error...");

// erster Test
try {
    print "First test\n";
    throw $e;
} catch (\Exception $ex1) {
    print $ex1->getMessage() . "\n";
} finally {
    print "Done\n";
}

// zweiter Test
try {
    print "Second test\n";
} catch (\Exception $ex1) {
    print $ex1->getMessage() . "\n";
} finally {
    print "Done\n";
}

// dritter Test
try {
    print "Third test\n";
    return;
} catch (\Exception $ex1) {
    print $ex1->getMessage() . "\n";
} finally {
    print "Done\n";
}

Code-Kommentare

  • Zeile 7: [$e] ist eine Instanz der vordefinierten Klasse [\Exception]. Wir werden sie an verschiedenen Stellen instanziieren;
  • Zeilen 11–12: Die Ausnahme [$e] wird in [try] durch die Anweisung [throw] ausgelöst;
  • Zeile 13: Die Ausnahme [\Exception] wird abgefangen und ihre Fehlermeldung auf die Konsole geschrieben;
  • Zeilen 15–16: Die Klausel [finally] schreibt eine Meldung. Nach den bisherigen Ausführungen müsste diese Meldung immer geschrieben werden, unabhängig davon, ob in [try] ein Fehler auftritt;
  • Zeile 21: In [try] gibt es keinen Fehler. Auch hier müsste das Programm zu [finally] übergehen;
  • Zeile 31: Es gibt eine Anweisung [return] in der Klausel [try], und es gibt keinen Fehler. Es stellt sich daher die Frage, ob das Skript zur Klausel [finally] übergeht. Die Ausführung zeigt, dass es das tut. Außerhalb einer Funktion beendet die Anweisung [return] das Skript.

Ergebnisse:

1
2
3
4
5
6
7
8
> php exceptions-04.php
First test
Error...
Done
Second test
Done
Third test
Done

Betrachten wir einen weiteren Fall, [exceptions-05.php]:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter
declare(strict_types=1);

// vierter Test
try {
    print "Fourth test\n";
    exit;
} finally {
    print "Done\n";
}

Kommentare

  • Zeile 9: Die Anweisung [exit] beendet die Ausführung des Skripts sofort: Die Klausel [finally] wird nicht ausgeführt;
  • Zeilen 7–12: Ein Beispiel für [try / finally] ohne die Klausel [catch]. Das ist möglich.

Ergebnisse:

> php exceptions-05.php
Fourth test

7.8. Eigene Ausnahmeklassen erstellen

In einem etwas größeren Projekt ist es nützlich, verschiedene Fehler zu unterscheiden, indem man sie in unterschiedlichen Ausnahmeklassen kapselt. In den vorherigen Skripten haben wir gesehen, dass jede Ausnahme von einer Klausel [catch (\Throwable $ex)] abgefangen werden kann. Das empfiehlt sich, wenn man keine Vorstellung davon hat, um welchen Fehler es sich handelt, und die Behandlung für alle Fehler gleich ist. Manchmal ist das der Fall, aber oft muss die Behandlung an den genauen Fehlertyp angepasst werden. Dann muss man die verschiedenen Fehler unterscheiden.

Betrachten wir das folgende Skript [exceptions-06.php]:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter
declare(strict_types=1);

// wir definieren unsere eigene Familie von Exceptions
class Exception1 extends \RuntimeException
{
}

class Exception2 extends \RuntimeException
{
}

// wir verwenden unsere Exceptions
$e1 = new Exception1("Error1...");
var_dump($e1);
$e2 = new Exception2("Error2...", 2);

// erster Test
print "first test\n";
try {
    // wir werfen eine Exception vom Typ Exception1
    throw $e1;
} catch (Exception1 $ex1) {
    print "Exception 1\n";
    print $ex1->getMessage() . "\n";
} catch (Exception2 $ex2) {
    print "Exception 2\n";
    print $ex2->getMessage() . "\n";
}

// zweiter Test
print "second test\n";
try {
    // wir werfen eine Exception vom Typ Exception2
    throw $e2;
} catch (Exception1 $ex1) {
    print "Exception 1\n";
    print $ex1->getMessage() . "\n";
} catch (Exception2 $ex2) {
    print "Exception 2\n";
    print $ex2->getMessage() . "\n";
}

// dritter Test
print "third test\n";
try {
    // wir werfen eine Exception vom Typ Exception1
    throw $e1;
} catch (Exception1 | Exception2 $ex) {
    print "Exception 1 or 2\n";
    print $ex->getMessage() . "\n";
}

// vierter Test
print "fourth test\n";
try {
    // wir werfen eine Exception vom Typ Exception2
    throw $e2;
} catch (Exception1 | Exception2 $ex) {
    print "Exception 1 or 2: " . $ex::class . "\n";
    // die von der Exception getragenen Informationen
    print "message: " . $ex->getMessage() . "\n";
    print "code: " . $ex->getCode() . "\n";
    print "file: " . basename($ex->getFile()) . "\n";
    print "line: " . $ex->getLine() . "\n";
}

Kommentare

  • Zeilen 7–9: Wir definieren zwei Klassen, *[Exception1] und *[Exception2], die beide von der vordefinierten Klasse ***[\\RuntimeException]*** abgeleitet sind. Der Rumpf dieser Klassen ist leer. Mit anderen Worten: Sie dienen allein ihrer Typen wegen: Gerade weil sie unterschiedliche Typen haben, können wir diese beiden Ausnahmen in den Klauseln [catch] unterscheiden;
  • Zeilen 16–18: Wir definieren zwei Variablen, [$e1] und [$e2], die die Typen [Exception1] bzw. [Exception2] haben. Verwendet wird der Konstruktor der Klasse [Exception], dessen Signatur [__construct(string $message = "", int $code = 0, ?Throwable $previous = null)] lautet. Für [$e2] wurde ein Fehlercode angegeben;
  • Zeilen 21–31: Hier gibt es eine Struktur [try / catch / catch]. Sie erlaubt es, verschiedene Ausnahmetypen mit verschiedenen Klauseln [catch] zu behandeln. Die erste Klausel, deren Typ passt, wird ausgeführt; die übrigen werden ignoriert;
  • Zeile 25: fängt Ausnahmen vom Typ [Exception1] ab;
  • Zeile 28: fängt Ausnahmen vom Typ [Exception2] ab;
  • Zeile 51: fängt Ausnahmen vom Typ [Exception1] oder ([|]) [Exception2] ab. Diese Syntax ist seit PHP 7.1 verfügbar;
  • Zeile 62: der Klassenname der abgefangenen Ausnahme;
  • Zeilen 64–67: die in der Ausnahme enthaltenen Informationen, abgerufen über die Methoden der Schnittstelle [Throwable]. Die Funktion [basename] liefert einen Dateinamen ohne den Ordnerpfad.

Ergebnisse:

> php exceptions-06.php
object(Exception1)#1 (7) {
  ["message":protected]=>
  string(9) "Error1..."
  ["string":"Exception":private]=>
  string(0) ""
  ["code":protected]=>
  int(0)
  ["file":protected]=>
  string(76) ".../php8-oct-2026/scripts-console/exceptions/exceptions-06.php"
  ["line":protected]=>
  int(16)
  ["trace":"Exception":private]=>
  array(0) {
  }
  ["previous":"Exception":private]=>
  NULL
}
first test
Exception 1
Error1...
second test
Exception 2
Error2...
third test
Exception 1 or 2
Error1...
fourth test
Exception 1 or 2: Exception2
message: Error2...
code: 2
file: exceptions-06.php
line: 18

Kommentare zu den Ergebnissen

  • Zeilen 2–18: Der „Inhalt“ einer Ausnahme, ausgegeben von [var_dump]:
    • Zeilen 3–4: die Fehlermeldung;
    • Zeilen 7–8: der Fehlercode;
    • Zeilen 9–10: der Name der Datei, in der die Ausnahme ausgelöst wurde. Die angegebene Länge (string(76)) ist die des vollständigen Dateipfads: Sie hängt vom Ordner ab, in dem sich das Skript befindet;
    • Zeilen 11–12: die Zeile, in der die Ausnahme ausgelöst wurde;
    • Zeilen 13–15: der Aufrufstapel zum Zeitpunkt, als die Ausnahme ausgelöst wurde. Er ist hier leer, weil die Ausnahme im Hauptskript und nicht innerhalb einer Funktion ausgelöst wurde;
    • Zeilen 16–17: die vorherige Ausnahme. Eine Ausnahme kann eine andere Ausnahme kapseln und so einen Ausnahmestapel bilden. Das Attribut [previous] erlaubt es, diesen Stapel zu analysieren;
  • Zeilen 29–33: Beachten Sie, dass Datei und Zeilennummer der Ausnahme die ihrer Erzeugung durch [new] (Zeile 18) sind und nicht die ihres Auslösens durch [throw].

7.9. Eine Ausnahme erneut auslösen

Eine Ausnahme kann mehrfach ausgelöst werden, wie das folgende Skript [exceptions-07.php] zeigt:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter
declare(strict_types=1);

try {
    try {
        // wir werfen eine Exception
        throw new \Exception("test");
    } catch (\Exception $ex) {
        // wir werfen die abgefangene Exception erneut
        throw $ex;
    } finally {
        // wir durchlaufen tatsächlich das finally
        print "finally 1\n";
    }
} catch (\Exception $ex2) {
    // wir erhalten tatsächlich die ursprüngliche Exception zurück
    print $ex2->getMessage() . " in outer try / catch / finally\n";
} finally {
    // wir durchlaufen tatsächlich das finally
    print "finally 2\n";
}

Kommentare

  • Zeile 9: Eine Ausnahme wird ausgelöst;
  • Zeile 10: Die Ausnahme wird abgefangen;
  • Zeile 12: Die Ausnahme wird erneut ausgelöst. Sie wird dann an die Struktur [try / catch / finally] der höheren Ebene weitergereicht. Dieses Szenario ist üblich: Code fängt eine Ausnahme ab, um eine lokale Verarbeitung durchzuführen (ein Log schreiben, eine Transaktion zurückrollen usw.), und löst sie dann erneut aus, damit auch der aufrufende Code benachrichtigt wird;
  • Zeile 17: Sie wird erneut abgefangen;
  • Zeilen 13–15: Die Ausführung zeigt, dass das Programm auch nach dem [throw] in Zeile 12 tatsächlich zur Klausel [finally] des inneren Blocks [try / catch / finally] übergeht.

Ergebnisse:

1
2
3
4
> php exceptions-07.php
finally 1
test in outer try / catch / finally
finally 2

7.10. Einen Ausnahmestapel behandeln

Eine Ausnahme kann eine andere Ausnahme kapseln, die ihrerseits eine weitere kapseln kann, sodass schließlich ein Ausnahmestapel entsteht. Hier ein Beispiel: [exceptions-08.php]:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter
declare(strict_types=1);

// wir definieren unsere eigene Familie von Exceptions
class Exception1 extends \RuntimeException
{
}

class Exception2 extends \RuntimeException
{
}

class Exception3 extends \RuntimeException
{
}

// wir verwenden unsere Exceptions
$e1 = new Exception1("Error 1...", 1, new Exception2("Error 2...", 2, new Exception3("Error 3...")));
var_dump($e1);
// Verwendung des Exception-Stacks
$e = $e1;
do {
    // Fehlermeldung der aktuellen Exception
    print $e::class . ": " . $e->getMessage() . "\n";
    // wir gehen zur vorherigen Exception über (null, falls es keine gibt)
    $e = $e->getPrevious();
} while ($e !== null);

Kommentare

  • Zeilen 7–15: Definition von drei Ausnahmeklassen, die von der vordefinierten Ausnahme [RuntimeException] abgeleitet sind;
  • Zeile 20: Eine Instanz der Klasse [Exception3] wird in einer Instanz der Klasse [Exception2] gekapselt, die ihrerseits in einer Instanz der Klasse [Exception1] gekapselt ist. Verwendet wird hier der Konstruktor der Klasse [Exception]: [__construct(string $message = "", int $code = 0, ?Throwable $previous = null)]. Der dritte Parameter des Konstruktors erlaubt es, eine Ausnahme zu kapseln. Das kann im folgenden Szenario nützlich sein:
    • Es wird eine Methode M definiert, die aus Kompatibilitätsgründen, etwa mit einer Schnittstelle, eine Ausnahme vom Typ [Exception1] – und nur von diesem Typ – auslösen darf;
    • Innerhalb der Methode M können jedoch andere Ausnahmetypen auftreten. Um einen Fehler an den Code weiterzugeben, der die Methode M aufruft, werden diese Ausnahmen dann in den Typ [Exception1] gekapselt, der anschließend ausgelöst wird. So ist sichergestellt, dass die Informationen der gekapselten Ausnahme – der ursprünglichen Fehlerursache – nicht verloren gehen;
  • Zeilen 24–29: zeigen, wie man den Stapel der in einer Ausnahme verschachtelten Ausnahmen durchläuft. Die Methode [getPrevious] liefert die gekapselte Ausnahme oder [null] , falls es keine gibt. Die Schleife [do ... while] führt ihren Rumpf mindestens einmal aus und läuft dann weiter, solange die Bedingung wahr ist.

Ergebnisse:

> php exceptions-08.php
object(Exception1)#1 (7) {
  ["message":protected]=>
  string(10) "Error 1..."
  ["string":"Exception":private]=>
  string(0) ""
  ["code":protected]=>
  int(1)
  ["file":protected]=>
  string(76) ".../php8-oct-2026/scripts-console/exceptions/exceptions-08.php"
  ["line":protected]=>
  int(20)
  ["trace":"Exception":private]=>
  array(0) {
  }
  ["previous":"Exception":private]=>
  object(Exception2)#2 (7) {
    ["message":protected]=>
    string(10) "Error 2..."
    ["string":"Exception":private]=>
    string(0) ""
    ["code":protected]=>
    int(2)
    ["file":protected]=>
    string(76) ".../php8-oct-2026/scripts-console/exceptions/exceptions-08.php"
    ["line":protected]=>
    int(20)
    ["trace":"Exception":private]=>
    array(0) {
    }
    ["previous":"Exception":private]=>
    object(Exception3)#3 (7) {
      ["message":protected]=>
      string(10) "Error 3..."
      ["string":"Exception":private]=>
      string(0) ""
      ["code":protected]=>
      int(0)
      ["file":protected]=>
      string(76) ".../php8-oct-2026/scripts-console/exceptions/exceptions-08.php"
      ["line":protected]=>
      int(20)
      ["trace":"Exception":private]=>
      array(0) {
      }
      ["previous":"Exception":private]=>
      NULL
    }
  }
}
Exception1: Error 1...
Exception2: Error 2...
Exception3: Error 3...
  • Zeilen 2–50: Die Ausnahme [$e1] enthält in ihrem Attribut [previous] die Ausnahme [Exception2] (Zeilen 17–49), die ihrerseits die Ausnahme [Exception3] (Zeilen 32–48) enthält;
  • Zeilen 51–53: der Aufrufstapel der Ausnahme.

7.11. Warnungen aus PHP 7, die in PHP 8 zu Fehlern wurden

Wir haben gesehen, dass die Division durch null, die in PHP 7 eine Warnung erzeugte, in PHP 8 einen Fehler auslöst. Das ist kein Einzelfall: PHP 8 hat viele Warnungen – bei denen die Ausführung früher mit einem falschen Ergebnis fortgesetzt wurde – in Fehler umgewandelt. Das Skript [exceptions-09.php] veranschaulicht einige davon:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter
declare(strict_types=1);

// zeigt den Typ und die Meldung eines Fehlers an
function display(int $n, \Throwable $ex): void
{
    print "$n - " . $ex::class . ": " . $ex->getMessage() . "\n";
}

// eine Funktion mit zwei Parametern
function sum(int $a, int $b): int
{
    return $a + $b;
}

// 1 - nicht definierte Variable: nur eine Warnung (Notice in PHP 7, Warning in PHP 8)
print "1 - [" . $unknown . "]\n";
// 2 - Modulo durch null: Warnung + falsches Ergebnis in PHP 7, Fehler in PHP 8
try {
    print 1 % 0;
} catch (\DivisionByZeroError $ex) {
    display(2, $ex);
}
// 3 - arithmetische Operation auf einem Array
try {
    print [] + 1;
} catch (\TypeError $ex) {
    display(3, $ex);
}
// 4 - arithmetische Operation auf einer nicht numerischen Zeichenkette
try {
    print "abc" * 2;
} catch (\TypeError $ex) {
    display(4, $ex);
}
// 5 - falscher Parametertyp für eine vordefinierte Funktion
try {
    print strlen([1, 2]);
} catch (\TypeError $ex) {
    display(5, $ex);
}
// 6 - Parameter vom richtigen Typ, aber mit ungültigem Wert
try {
    print_r(array_chunk([1, 2, 3], 0));
} catch (\ValueError $ex) {
    display(6, $ex);
}
// 7 - nicht genügend Argumente
try {
    print sum(1);
} catch (\ArgumentCountError $ex) {
    display(7, $ex);
}
// 8 - [match]-Ausdruck ohne passenden Zweig (PHP 8.0)
try {
    $day = 8;
    print match ($day) {
        6, 7 => "weekend",
        1, 2, 3, 4, 5 => "weekday",
    };
} catch (\UnhandledMatchError $ex) {
    display(8, $ex);
}
// 9 - Methode, die auf null aufgerufen wird
try {
    $object = null;
    $object->method();
} catch (\Error $ex) {
    display(9, $ex);
}
// 10 - der Nullsafe-Operator ?-> vermeidet den vorherigen Fehler: das Ergebnis ist null
var_dump($object?->method());

Ergebnisse:

> php exceptions-09.php

Warning: Undefined variable $unknown in .../php8-oct-2026/scripts-console/exceptions/exceptions-09.php on line 19
1 - []
2 - DivisionByZeroError: Modulo by zero
3 - TypeError: Unsupported operand types: array + int
4 - TypeError: Unsupported operand types: string * int
5 - TypeError: strlen(): Argument #1 ($string) must be of type string, array given
6 - ValueError: array_chunk(): Argument #2 ($length) must be greater than 0
7 - ArgumentCountError: Too few arguments to function sum(), 1 passed in .../php8-oct-2026/scripts-console/exceptions/exceptions-09.php on line 52 and exactly 2 expected
8 - UnhandledMatchError: Unhandled match case 8
9 - Error: Call to a member function method() on null
NULL

Kommentare

  • Zeile 19: Die Verwendung einer nicht definierten Variablen bleibt eine einfache Warnung, jedoch auf der Stufe [E_WARNING] (in PHP 7 war es ein Hinweis [E_NOTICE]). Die Variable wird auf [null] gesetzt, und das Skript läuft weiter (Zeilen 2–4 der Ergebnisse);
  • Zeile 22: Die Division durch null löst einen Fehler [DivisionByZeroError] aus (Zeile 5). Das war bereits in PHP 7 so: Nur die Division durch null mit [/] erzeugte dort eine einfache Warnung;
  • Zeile 28: Eine arithmetische Operation mit einem Array verursacht einen Fehler [TypeError] (Zeile 6);
  • Zeile 34: In PHP 7 löste eine arithmetische Operation mit einer nicht numerischen Zeichenkette die Warnung „A non-numeric value encountered“ aus, und die Zeichenkette wurde als 0 behandelt. In PHP 8 ist das ein Fehler [TypeError] (Zeile 7). Eine numerische Zeichenkette (["12" * 2]) wird weiterhin akzeptiert;
  • Zeile 40: In PHP 7 löste die Übergabe eines Parameters des falschen Typs an eine vordefinierte Funktion eine Warnung aus, und die Funktion lieferte [null]. In PHP 8 lösen alle vordefinierten Funktionen einen Fehler [TypeError] aus, genau wie die vom Entwickler geschriebenen Funktionen (Zeile 8). Die Meldung bezeichnet den Parameter durch seine Nummer und seinen Namen;
  • Zeile 46: Der Parameter hat den richtigen Typ ([int]), aber einen ungültigen Wert (eine Länge muss positiv sein): Das ist der Fehler [ValueError], neu in PHP 8.0 (Zeile 9). In PHP 7 war das eine Warnung;
  • Zeile 52: Die Funktion [sum] erwartet zwei Argumente, erhält aber nur eines: Fehler [ArgumentCountError] (Zeile 10);
  • Zeilen 59–62: Der Ausdruck [match] hat keinen Zweig für den Wert 8 und keinen Zweig [default]: Fehler [UnhandledMatchError] (Zeile 11). Das ist ein wesentlicher Unterschied zur Anweisung [switch], die nichts tut, wenn kein [case] passt;
  • Zeile 69: Der Aufruf einer Methode auf [null] führt zu einem Fehler [Error] (Zeile 12). Das war bereits in PHP 7 so;
  • Zeile 74: Der Null-Safe-Operator [?->] (PHP 8.0) liefert [null] , wenn das Objekt [null] ist, anstatt die Methode aufzurufen. So muss kein Test [if ($object !== null)] geschrieben werden (Zeile 13).

Diese Änderungen machen PHP-8-Programme sicherer: Ein Fehler stoppt die Verarbeitung, anstatt sie mit falschen Daten fortzusetzen. Sie verlangen vom Entwickler aber auch, die entsprechenden Klauseln [catch] einzubauen.

7.12. Mehrere [catch], [catch] ohne Variable und [throw] als Ausdruck

Das Skript [exceptions-10.php] zeigt drei Neuerungen von PHP 8 und eine gängige Verwendung der Ausnahmebehandlung:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter
declare(strict_types=1);

// [throw] ist seit PHP 8.0 ein Ausdruck: er kann nach ?? oder in einer Pfeilfunktion verwendet werden
function readAge(array $data): int
{
    $age = $data["age"] ?? throw new \InvalidArgumentException("The age is missing");
    return is_int($age) && $age >= 0 ? $age : throw new \DomainException("Invalid age [$age]");
}

// eine Pfeilfunktion, die nur eine Exception wirft
$forbidden = fn(string $operation) => throw new \LogicException("Operation [$operation] forbidden");

// Testdaten
$tests = [["age" => 48], [], ["age" => -4]];
foreach ($tests as $i => $data) {
    try {
        print "test $i: age=" . readAge($data) . "\n";
    } catch (\InvalidArgumentException | \DomainException $ex) {
        // eine einzige [catch]-Klausel für zwei Exception-Typen
        print "test $i: " . $ex::class . ": " . $ex->getMessage() . "\n";
    }
}

try {
    $forbidden("deletion");
} catch (\LogicException) {
    // seit PHP 8.0 ist die Variable der [catch]-Klausel optional
    print "the operation was refused\n";
}

// Einhüllen einer Low-Level-Exception in eine Anwendungs-Exception
class DaoException extends \RuntimeException
{
}

function readConfiguration(string $json): array
{
    try {
        return json_decode($json, true, flags: JSON_THROW_ON_ERROR);
    } catch (\JsonException $ex) {
        // die ursprüngliche Ursache wird als 3. Parameter übergeben: sie geht nicht verloren
        throw new DaoException("Unreadable configuration", 10, $ex);
    }
}

try {
    readConfiguration('{"dsn": "mysql:host=localhost"');
} catch (DaoException $ex) {
    print $ex::class . ": " . $ex->getMessage() . " (code " . $ex->getCode() . ")\n";
    print "cause: " . $ex->getPrevious()::class . ": " . $ex->getPrevious()->getMessage() . "\n";
}

Ergebnisse:

1
2
3
4
5
6
7
> php exceptions-10.php
test 0: age=48
test 1: InvalidArgumentException: The age is missing
test 2: DomainException: Invalid age [-4]
the operation was refused
DaoException: Unreadable configuration (code 10)
cause: JsonException: Syntax error

Kommentare

  • Zeile 9: Ab PHP 8.0 ist [throw] ein Ausdruck und nicht mehr nur eine Anweisung. Es kann daher überall dort verwendet werden, wo ein Wert erwartet wird: hier nach dem Operator [??]. Existiert der Schlüssel [age] nicht, wird eine Ausnahme ausgelöst; andernfalls wird [$age] sein Wert zugewiesen;
  • Zeile 10: [throw] in einem bedingten Ausdruck [? :] verwendet;
  • Zeile 14: eine Pfeilfunktion, deren Rumpf lediglich eine Ausnahme auslöst. Vor PHP 8.0 war das nicht möglich: Eine Pfeilfunktion darf nur einen Ausdruck enthalten;
  • Zeile 21: eine einzige Klausel [catch] für zwei Ausnahmetypen (Zeilen 3–4 der Ergebnisse). Beachten Sie, dass [InvalidArgumentException] und [DomainException] beide von [LogicException] abgeleitet sind: Ein [catch (\LogicException $ex)] hätte dieselbe Wirkung gehabt;
  • Zeile 29: Ab PHP 8.0 ist die Variable in der Klausel [catch] optional, wenn man nicht die Ausnahme selbst, sondern nur ihren Typ benötigt (Zeile 5);
  • Zeilen 35–37: eine anwendungsspezifische Ausnahme. In den folgenden Kapiteln schreiben wir Datenzugriffsschichten (DAO, Data Access Object), die nur diesen Ausnahmetyp auslösen, unabhängig von der Fehlerquelle (Datei, JSON, Datenbank);
  • Zeilen 39–47: Die Funktion [readConfiguration] dekodiert eine JSON-Zeichenkette. Die Low-Level-Ausnahme [JsonException] wird abgefangen und (Zeile 45) in eine Ausnahme [DaoException] verpackt. Die ursprüngliche Ursache wird als dritter Parameter an den Konstruktor übergeben;
  • Zeile 53: Der aufrufende Code kennt nur [DaoException], kann aber die ursprüngliche Fehlerursache mit der Methode [getPrevious] abrufen (Zeilen 6–7 der Ergebnisse).

7.13. Warnungen in Ausnahmen umwandeln: [ErrorException]

Trotz der Verbesserungen in PHP 8 bleiben bestimmte Anomalien bloße Warnungen: nicht vorhandener Array-Schlüssel, nicht definierte Variable, Datei, die sich mit [fopen] nicht öffnen lässt ... Diese Warnungen lassen sich nicht mit einem [try / catch] abfangen. Sie können jedoch einen Fehlerhandler installieren, der sie in Ausnahmen vom Typ [ErrorException] umwandelt. Genau das tut das Skript [exceptions-11.php]:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter
declare(strict_types=1);

// Fehlerbehandler: wandelt PHP-Warnungen in [ErrorException]-Exceptions um
set_error_handler(function (int $level, string $message, string $file, int $line): bool {
    throw new \ErrorException($message, 0, $level, $file, $line);
});

// ein unbekannter Schlüssel löst nicht mehr nur eine Warnung, sondern eine Exception aus
$person = ["lastName" => "Langevin"];
try {
    print $person["firstName"] . "\n";
} catch (\ErrorException $ex) {
    print "Error: " . $ex->getMessage() . " (line " . $ex->getLine() . ")\n";
    print "level E_WARNING: " . var_export($ex->getSeverity() === E_WARNING, true) . "\n";
}
// dasselbe beim Öffnen einer nicht existierenden Datei
try {
    $stream = fopen(__DIR__ . "/nonexistent.txt", "r");
} catch (\ErrorException $ex) {
    print "Error: " . $ex->getMessage() . "\n";
}
// wir kehren zum PHP-Fehlerbehandler zurück
restore_error_handler();
print "end\n";

Ergebnisse:

1
2
3
4
5
> php exceptions-11.php
Error: Undefined array key "firstName" (line 14)
level E_WARNING: true
Error: fopen(.../php8-oct-2026/scripts-console/exceptions/nonexistent.txt): Failed to open stream: No such file or directory
end

Kommentare

  • Zeilen 7–9: Die Funktion [set_error_handler] richtet einen Fehlerhandler ein – eine Funktion, die PHP aufruft, sobald eine Warnung, ein Hinweis oder eine Deprecation-Meldung auftritt, anstatt die Meldung anzuzeigen. Sie erhält die Fehlerstufe, die Fehlermeldung, die Datei und die Zeile, in der der Fehler aufgetreten ist. Hier löst sie eine Ausnahme vom Typ [ErrorException] aus, die diese Informationen speichert. Der Rückgabetyp [bool] entspricht der Angabe in der Dokumentation von [set_error_handler]: Die Funktion würde [false] zurückgeben, damit PHP den Fehler normal behandelt. Hier gibt sie nie etwas zurück, weil sie immer eine Ausnahme auslöst;
  • Zeile 14: Der Schlüssel [firstName] existiert nicht. Anstelle einer Warnung wird eine Ausnahme [ErrorException] ausgelöst und abgefangen (Zeile 2 der Ergebnisse);
  • Zeile 17: Die Methode [getSeverity], die für die Klasse [ErrorException] spezifisch ist, liefert die Stufe des ursprünglichen Fehlers (Zeile 3);
  • Zeile 21: Auch der Versuch, eine nicht vorhandene Datei zu öffnen, führt zu einer Ausnahme (Zeile 4);
  • Zeile 26: stellt den vorherigen Fehlerhandler wieder her, in diesem Fall den von PHP.

Diese Technik wird von vielen PHP-Frameworks (Symfony, Laravel) verwendet: Während der Entwicklung wird jede Warnung zu einer Ausnahme, was den Entwickler zwingt, den Code zu korrigieren. Das Testwerkzeug [PHPUnit], das wir später verwenden werden, funktioniert ähnlich: Es kann einen Test fehlschlagen lassen, wenn dieser eine Warnung oder eine Deprecation-Meldung erzeugt.