mitmario.dev

Eigene Ausnahmen

PHP Sandbox 3 Min Lesezeit 4 BeispieleLektion 3 von 6

An einer Anmeldung kann zweierlei schiefgehen. Der Name fehlt, oder das Alter ist unmöglich. Wirft der Code für beides dieselbe InvalidArgumentException, muss der Aufrufer in der Meldung nach einem Stichwort suchen. Erst dann weiß er, ob er zurückfragt oder ablehnt.

Eine eigene Ausnahmeklasse in drei Zeilen

Eine eigene Ausnahme in drei Zeilen
<?php

declare(strict_types=1);

class LagerLeerException extends RuntimeException
{
}

function nimmAusLager(int $vorrat, int $menge): int
{
    if ($menge > $vorrat) {
        throw new LagerLeerException("Nur noch " . $vorrat . " Stück da");
    }

    return $vorrat - $menge;
}

foreach ([[10, 3], [7, 99]] as [$vorrat, $menge]) {
    try {
        $rest = nimmAusLager($vorrat, $menge);
        echo "Rest: ", $rest, "\n";
    } catch (LagerLeerException $fehler) {
        echo "Lager: ", $fehler->getMessage(), "\n";
    }
}

class LagerLeerException extends RuntimeException {} legt eine neue Ausnahme an. Sie kann alles, was RuntimeException kann, und unterscheidet sich nur durch ihren Namen.

Kürzer geht eine Klasse nicht. Ein Name, ein extends, und zwischen den geschweiften Klammern steht nichts. Alles, was sie braucht, erbt sie. Mehr über Klassen kommt in Abschnitt 13.

PHP verlangt die Endung Exception im Namen nicht. Sie steht trotzdem fast immer da. Suchst du später die Ausnahmen eines Programms, suchst du nach diesem Wort.

Der Aufrufer kann unterscheiden

Zwei Fälle, zwei catch-Blöcke
<?php

declare(strict_types=1);

class NameFehltException extends InvalidArgumentException
{
}

class AlterUngueltigException extends InvalidArgumentException
{
}

function pruefeAnmeldung(array $anmeldung): void
{
    if (trim($anmeldung["name"]) === "") {
        throw new NameFehltException("Name fehlt");
    }

    if ($anmeldung["alter"] < 6 || $anmeldung["alter"] > 99) {
        throw new AlterUngueltigException("Alter " . $anmeldung["alter"] . " ist nicht möglich");
    }
}

$anmeldungen = [
    ["name" => "Mia", "alter" => 34],
    ["name" => "", "alter" => 17],
    ["name" => "Tom", "alter" => 410],
];

foreach ($anmeldungen as $anmeldung) {
    try {
        pruefeAnmeldung($anmeldung);
        echo "Angemeldet: ", $anmeldung["name"], "\n";
    } catch (NameFehltException $fehler) {
        echo "Rückfrage: ", $fehler->getMessage(), "\n";
    } catch (AlterUngueltigException $fehler) {
        echo "Nicht angemeldet: ", $fehler->getMessage(), "\n";
    }
}

Hier stehen zwei Ausnahmen für zwei verschiedene Probleme, und der Aufrufer behandelt sie unterschiedlich. Fehlt der Name, fragt er zurück. Ist das Alter unmöglich, meldet er nicht an.

Mit einer einzigen Ausnahme und zwei verschiedenen Meldungen müsste der catch-Block in den Text hineinsehen, etwa mit str_contains($fehler->getMessage(), "Name"). Damit hängt das Programm an einem Wortlaut. Ändert jemand die Meldung oder wird sie irgendwann übersetzt, geht der Zweig still kaputt.

Mit eigenen Klassen fragt der catch-Block nach dem Typ, und der bleibt derselbe, auch wenn jemand die Meldung umformuliert. Der Text ist dann nur noch für Menschen da.

Ein try darf beliebig viele catch-Blöcke haben. Passt keiner, fliegt die Ausnahme weiter nach oben, als stünde das try gar nicht da.

Die Reihenfolge zählt, und niemand warnt dich

Von speziell nach allgemein
<?php

declare(strict_types=1);

class NameFehltException extends InvalidArgumentException
{
}

echo "Richtig herum, speziell zuerst:\n";
try {
    throw new NameFehltException("Name fehlt");
} catch (NameFehltException $fehler) {
    echo "  NameFehltException\n";
} catch (InvalidArgumentException $fehler) {
    echo "  InvalidArgumentException\n";
}

echo "Falsch herum, allgemein zuerst:\n";
try {
    throw new NameFehltException("Name fehlt");
} catch (InvalidArgumentException $fehler) {
    echo "  InvalidArgumentException, und zwar ein ", get_class($fehler), "\n";
} catch (NameFehltException $fehler) {
    echo "  Diese Zeile ist nicht zu erreichen\n";
}

Beide Ausnahmen im Beispiel sind eine NameFehltException, und beide try-Blöcke haben dieselben zwei catch-Blöcke. Nur die Reihenfolge ist vertauscht. Und schon kommt etwas anderes heraus.

PHP nimmt den ersten catch-Block, der passt. NameFehltException erbt von InvalidArgumentException, also passt der allgemeine Block auch auf die spezielle Ausnahme. Steht er oben, fängt er alles, und der speziellere darunter kommt nie dran.

Unangenehm daran ist, dass PHP nichts dazu sagt. Der Exit-Code bleibt 0. Das Programm behandelt einfach alles gleich, und du merkst es nur an der falschen Ausgabe, wie bei einer Warnung. Im Reiter Debug taucht die Zeile mit Diese Zeile ist nicht zu erreichen in der Aufzeichnung nie auf, und fehler heißt im allgemeinen catch-Block trotzdem NameFehltException.

Der engste Typ gehört also nach oben, der weiteste nach unten. Erbt eine Klasse von einer anderen, ist sie die engere, und mit dieser einen Regel bringst du auch eine lange Reihe von catch-Blöcken in die richtige Reihenfolge.

Wenn zwei Fälle doch dasselbe bekommen sollen

Mehrere Ausnahmeklassen in einem catch
<?php

declare(strict_types=1);

class NameFehltException extends InvalidArgumentException
{
}

class AlterUngueltigException extends InvalidArgumentException
{
}

foreach (["name", "alter"] as $fall) {
    try {
        if ($fall === "name") {
            throw new NameFehltException("Name fehlt");
        }
        throw new AlterUngueltigException("Alter 410 ist nicht möglich");
    } catch (NameFehltException | AlterUngueltigException $fehler) {
        echo "Anmeldung abgelehnt: ", $fehler->getMessage(), "\n";
    }
}

Manchmal willst du unterscheiden können, tust es an dieser Stelle aber nicht. Mit dem senkrechten Strich passen dann mehrere Klassen in einen Block. catch (NameFehltException | AlterUngueltigException $fehler) fängt beide und nur diese beiden.

Das ist besser als ein catch (InvalidArgumentException $fehler), obwohl das hier dasselbe täte. Am Strich siehst du, welche zwei Fälle erwartet werden. Kommt später eine dritte Ausnahmeklasse dazu, fliegt sie durch und fällt auf, statt still mitbehandelt zu werden.

Übertrieben ist eine eigene Ausnahme, wenn es nur einen Fall gibt und niemand ihn von einem anderen unterscheiden muss. Dann reicht eine RuntimeException mit einer guten Meldung. Lohnen tut sich eine eigene Ausnahmeklasse ab dem Moment, in dem irgendwo ein zweiter catch-Block danebenstehen könnte und jemand die beiden Fälle auseinanderhalten will.

Zwei kaputte Posten einer Bestellung bekommen in der Aufgabe je ihre eigene Ausnahme.

Zum Mitnehmen

Eine eigene Ausnahme ist eine Klasse mit extends und leeren Klammern. Ihr Typ sagt dem Aufrufer, welcher Fall vorliegt, ohne dass er die Meldung lesen muss, und bei mehreren catch-Blöcken steht der speziellste oben.

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 4 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe, dein Code läuft auf einem Server

    Öffnet sich mit dem Basis Konto.