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]:
7.2. Die Schnittstelle [\Throwable]
Die Schnittstelle [\Throwable] sieht wie folgt aus (siehe Dokumentation):
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:
Ergebnisse:
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:
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:
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:
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:
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]:
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:
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:
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:
Betrachten wir einen weiteren Fall, [exceptions-05.php]:
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:
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]:
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:
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:
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:
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]:
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:
- 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:
Ergebnisse:
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:
Ergebnisse:
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]:
Ergebnisse:
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.