mitmario.dev

Ausnahmen fangen

PHP Sandbox 4 Min Lesezeit 5 BeispieleLektion 2 von 6

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

Ein kaputter Wert, und der Rest läuft weiter
<?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

finally läuft in jedem Fall
<?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

Die Meldung oder die ganze Ausnahme
<?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

Ein leerer catch ist schlimmer als kein catch
<?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

Exception fängt keinen Error
<?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, kostenlos

Zu 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.