Abschnitt 7 · Lektion 2
Ausnahmen fangen
Hundert Zeilen sollen eingelesen werden, und in der dritten steht Unsinn. Wirft der Code beim Prüfen
dieser Zeile eine Ausnahme, ist das Programm dort zu Ende. Die siebenundneunzig guten Zeilen danach
kommen nie dran. Mit try und catch bekommt die kaputte Zeile eine eigene Behandlung, und der
Rest läuft weiter.
Möglichst wenig in den try-Block
<?php
declare(strict_types=1);
$eingaben = ["12", "acht", "30"];
foreach ($eingaben as $eingabe) {
try {
if (!is_numeric($eingabe)) {
throw new InvalidArgumentException("keine Zahl: " . $eingabe);
}
echo "Alter: ", (int) $eingabe, "\n";
} catch (InvalidArgumentException $fehler) {
echo "Übersprungen, ", $fehler->getMessage(), "\n";
}
}
echo "Fertig.\n"; Der try-Block umschließt, was schiefgehen kann. Der catch-Block dahinter sagt, was dann
passieren soll. Im Beispiel ist die zweite von drei Eingaben Text, und die dritte kommt trotzdem
noch dran.
Der try-Block sitzt in der Schleife und nicht um sie herum. Läge er außen, würde die kaputte
zweite Eingabe die ganze Schleife beenden, und die 30 käme nie an die Reihe.
In den try-Block gehört deshalb so wenig wie möglich. Nur die Zeilen, die wirklich schiefgehen
können, und nichts, was danach sowieso noch passieren soll. Ein try um eine halbe Datei fängt am
Ende auch die Fehler, an die beim Schreiben niemand gedacht hat, und behandelt sie dann alle gleich.
throw wirft eine Ausnahme, und new InvalidArgumentException(...) legt sie an. Das sind Objekte
wie die aus Abschnitt 6. Hier reicht, dass hinter new ein Name steht und in den Klammern die
Meldung. Wann sich eigenes Werfen lohnt, steht in der Lektion über Werfen statt Zurückgeben.
finally läuft, egal was passiert
<?php
declare(strict_types=1);
function lies(string $was): string
{
echo " Datei geöffnet\n";
try {
if ($was === "kaputt") {
throw new RuntimeException("Datei ist kaputt");
}
return "Inhalt von " . $was;
} finally {
echo " Datei geschlossen\n";
}
}
echo "Erster Versuch:\n";
echo lies("brief.txt"), "\n";
echo "Zweiter Versuch:\n";
try {
echo lies("kaputt"), "\n";
} catch (RuntimeException $fehler) {
echo "Gefangen: ", $fehler->getMessage(), "\n";
} An try darf hinten ein finally hängen, und dessen Block läuft immer. Auch dann, wenn der
try-Block mit return verlassen wird. Auch dann, wenn eine Ausnahme durchfliegt und erst weiter
oben gefangen wird.
Im ersten Versuch steht Datei geschlossen vor dem Inhalt. Die Funktion hat ihren Rückgabewert zu
diesem Zeitpunkt schon fertig und führt trotzdem noch das finally aus, bevor der Wert beim
Aufrufer ankommt. Im zweiten Versuch fliegt eine Ausnahme aus dem try heraus, und das finally
läuft auch hier. Zeile für Zeile siehst du das im Reiter Debug mit Aufzeichnen. Nach der
return-Zeile kommt dort noch einmal die Zeile mit Datei geschlossen, und erst dann geht es beim
Aufrufer weiter.
Gedacht ist finally zum Aufräumen, also für alles, was passieren muss, egal wie die Sache ausgeht.
Eine Datei schließen zum Beispiel, oder eine Verbindung beenden.
Ein return im finally-Block ist möglich und überschreibt dann das return aus dem try. Das
liest sich wie ein Zaubertrick, und niemand rechnet damit.
Was du aus einer Ausnahme herausholst
<?php
declare(strict_types=1);
try {
throw new RuntimeException("Die Datenbank antwortet nicht");
} catch (RuntimeException $fehler) {
echo "Nur die Meldung:\n";
echo $fehler->getMessage(), "\n";
echo "\nDie ganze Ausnahme:\n";
echo $fehler, "\n";
}
echo "\nUnd eine Meldung, die selbst einen Pfad enthält:\n";
function alterVon(int $jahr): int
{
return 2026 - $jahr;
}
try {
alterVon("neunzehn");
} catch (TypeError $fehler) {
echo $fehler->getMessage(), "\n";
} getMessage() gibt dir den Text, mit dem die Ausnahme angelegt wurde. Das ist fast immer das, was
du willst.
Gibst du die ganze Ausnahme aus, bekommst du den Klassennamen, die Meldung, den vollen Pfad der
Datei, die Zeilennummer und obendrauf einen Stacktrace (englisch stack trace). In diesem Kurs ist
der Pfad /vercel/sandbox/lern/index.php, auf einem echten Server der Pfad, unter dem deine
Anwendung liegt. Das sollte niemand von außen erfahren. Was ein Angreifer mit dem anfängt, was eine
Fehlermeldung so ausplaudert, steht in Abschnitt 15.
Bei einem TypeError, im letzten Teil des Beispiels, steht der Pfad allerdings schon in der Meldung
selbst. getMessage() ist also die bessere Wahl, aber keine Garantie. Ohne Pfad bleibt die Ausgabe
nur, wenn du den Satz für den Nutzer selbst schreibst. Die Einzelheiten gehören ins Protokoll, und
das kommt mit der Lektion über Fehler im Betrieb dazu.
Der Block, der nichts tut
<?php
declare(strict_types=1);
function preisInCent(string $eingabe): int
{
try {
if (!is_numeric($eingabe)) {
throw new InvalidArgumentException("Das ist keine Zahl");
}
return (int) round((float) $eingabe * 100);
} catch (InvalidArgumentException $fehler) {
// Hier steht nichts, und das ist das Problem.
}
return 0;
}
echo "Ein Preis: ", preisInCent("24.99"), "\n";
echo "Ein Tippfehler: ", preisInCent("24,99"), "\n";
echo "Beide Zeilen sehen gleich vertrauenswürdig aus.\n"; Ein catch-Block ohne Inhalt fängt die Ausnahme und schweigt. Das Programm läuft weiter, als wäre
nichts gewesen. Es liefert 0, und das sieht genauso aus wie ein richtiges Ergebnis.
Ohne try wäre das Programm abgestürzt, und jemand hätte den Fehler gefunden. So ist aus einem
lauten Problem ein leises geworden, wie bei der Warnung.
Ein Kommentar im catch-Block sagt wenigstens, warum dort nichts passiert. Eine Meldung auf dem
Fehlerkanal sagt es auch dem, der das Programm laufen lässt.
Error und Exception sind zwei Familien
<?php
declare(strict_types=1);
echo "Erster Versuch, mit Exception:\n";
try {
try {
intdiv(100, 0);
} catch (Exception $fehler) {
echo " gefangen als Exception\n";
}
} catch (Throwable $fehler) {
echo " durchgeflogen, es war ein ", get_class($fehler), "\n";
}
echo "Zweiter Versuch, mit Throwable:\n";
try {
intdiv(100, 0);
} catch (Throwable $fehler) {
echo " gefangen als Throwable\n";
} catch (Exception $fehler) fängt nur Ausnahmen aus der Exception-Familie. Ein
DivisionByZeroError gehört nicht dazu, denn er ist ein Error. Der fliegt an so einem catch
vorbei, als stünde es gar nicht da.
Über beiden Familien steht Throwable. Ein catch (Throwable $fehler) fängt alles, und damit auch
jeden Fehler, mit dem an dieser Stelle niemand gerechnet hat.
In der Aufgabe kommen drei Zeilen JSON herein, und eine davon ist kaputt.
Zum Mitnehmen
In den try-Block kommt nur, was wirklich schiefgehen kann, der catch-Block sagt, was dann passiert, und finally läuft danach in jedem Fall. Ausgegeben wird getMessage() oder ein eigener Satz, nie die ganze Ausnahme, und ein leerer catch macht aus einem lauten Fehler einen leisen.
Jetzt du
Basis Konto, kostenlosZu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.
Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.
In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.
Was in dieser Lektion steckt
-
Artikel mit 5 Beispielen zum Ausprobieren
Steht hier, ohne Konto lesbar.
-
Aufgabe, dein Code läuft auf einem Server
Öffnet sich mit dem Basis Konto.