mitmario.dev

Statisch, Konstanten, Enums

PHP Sandbox 4 Min Lesezeit 5 BeispieleLektion 2 von 6

Die Obergrenze für einen Notiztitel ist für jede Notiz dieselbe. Steht sie in jedem Objekt, kann sie in einem anders sein als im nächsten. Merken würde das niemand. Manches gehört eben zur Klasse als Ganzes und zu keinem einzelnen Objekt.

Konstanten und static

Was zur Klasse gehört und nicht zum Objekt
<?php

declare(strict_types=1);

class Notiz
{
    public const MAX_LAENGE = 20;

    private static int $angelegt = 0;

    public function __construct(public readonly string $titel)
    {
        self::$angelegt++;
    }

    public function kurz(): string
    {
        return substr($this->titel, 0, self::MAX_LAENGE);
    }

    public static function anzahl(): int
    {
        return self::$angelegt;
    }
}

$eins = new Notiz("Milch kaufen");
$zwei = new Notiz("Brot holen und Kaffee mitnehmen");

echo $eins->kurz(), "\n";
echo $zwei->kurz(), "\n";

// Beides ohne ein Objekt in der Hand: die Konstante und der Zaehler.
echo "Obergrenze: ", Notiz::MAX_LAENGE, "\n";
echo "Angelegt:   ", Notiz::anzahl(), "\n";

Eine Klassenkonstante steht mit const in der Klasse und ändert sich nie. Von innen liest du sie mit self::MAX_LAENGE, von außen mit Notiz::MAX_LAENGE. Ein Objekt brauchst du dafür nicht. Der Pfeil geht an ein Objekt, der doppelte Doppelpunkt :: an die Klasse.

Eine statische Eigenschaft gehört ebenfalls der Klasse, kann sich aber ändern. Im Beispiel zählt self::$angelegt mit, wie viele Notizen es insgesamt gibt. Das ist eine Zahl für alle Objekte zusammen und nicht eine je Objekt.

In einer statischen Methode gibt es kein $this. Sie wird an der Klasse aufgerufen, und da ist kein Objekt, auf das $this zeigen könnte. Deshalb steht an der Zeile in anzahl() im Reiter Debug „Noch keine Variablen“.

Wofür static gedacht ist

Eine Erzeugermethode statt eines zweiten Konstruktors
<?php

declare(strict_types=1);

class Notiz
{
    public function __construct(
        public readonly string $titel,
        public readonly bool $erledigt,
    ) {
    }

    // Ein zweiter Konstruktor waere praktisch. Den gibt es in PHP
    // nicht, eine statische Methode tut dieselbe Arbeit.
    public static function ausZeile(string $zeile): self
    {
        $teile = explode("|", $zeile);

        return new self(trim($teile[0]), trim($teile[1] ?? "") === "x");
    }
}

$eins = new Notiz("Milch kaufen", false);
$zwei = Notiz::ausZeile("Brot holen | x");

foreach ([$eins, $zwei] as $notiz) {
    echo $notiz->titel, ": ", $notiz->erledigt ? "erledigt" : "offen", "\n";
}

PHP erlaubt einen einzigen Konstruktor je Klasse. Manchmal soll ein Objekt aber auf zwei Wegen entstehen, einmal aus Einzelwerten und einmal aus einer Zeile Text. Dann baut eine statische Erzeugermethode das Objekt und gibt es zurück. Der Rückgabetyp self heißt „ein Objekt dieser Klasse“.

Für solche Methoden ist static gedacht, und sonst nehme ich es in diesem Kurs sparsam. Eine öffentliche statische Eigenschaft ist ein Wert, an den jede Stelle im Programm herankommt und den jede Stelle ändern kann, so wie eine Variable mit global im Abschnitt über Funktionen. Auch eine private gilt für alle Objekte zugleich, und jedes davon kann sie verstellen. Für einen Zähler geht das in Ordnung. Bei einem Wert, der das Programm steuert, weiß am Ende niemand mehr, wer ihn gesetzt hat.

Der Fall, für den man früher Konstanten genommen hat

Drei Konstanten, an die sich niemand hält
<?php

declare(strict_types=1);

const PRIO_NIEDRIG = "niedrig";
const PRIO_NORMAL = "normal";
const PRIO_HOCH = "hoch";

function beschriftung(string $prio): string
{
    if ($prio === PRIO_HOCH) {
        return "heute noch";
    } elseif ($prio === PRIO_NORMAL) {
        return "diese Woche";
    }

    return "irgendwann";
}

// Die Konstante ist nur ein Angebot. Der Parameter nimmt jeden Text,
// und niemand haelt einen davon ab, einen anderen hinzuschreiben.
echo beschriftung(PRIO_HOCH), "\n";
echo beschriftung("Hoch"), "\n";
echo beschriftung("ganz dringend"), "\n";

Oft ist ein Wert eine von wenigen erlaubten Möglichkeiten. Eine Priorität ist zum Beispiel niedrig, normal oder hoch. Drei Konstanten dafür sind schnell geschrieben, nur reichen sie nicht.

beschriftung(string $prio) nimmt jeden beliebigen Text entgegen, denn PRIO_HOCH ist ja nur ein anderer Name für "hoch". "Hoch" mit großem H geht durch, "ganz dringend" auch, und beide landen still im letzten Zweig, bei „irgendwann“. PHP meldet nichts. Falsch ist das Ergebnis trotzdem.

Ein Enum macht aus der Liste einen Typ

Dasselbe als Enum
<?php

declare(strict_types=1);

enum Prioritaet: string
{
    case Niedrig = "niedrig";
    case Normal = "normal";
    case Hoch = "hoch";
}

function beschriftung(Prioritaet $prio): string
{
    return match ($prio) {
        Prioritaet::Niedrig => "irgendwann",
        Prioritaet::Normal => "diese Woche",
        Prioritaet::Hoch => "heute noch",
    };
}

echo beschriftung(Prioritaet::Hoch), "\n";

// Die ganze Liste, ohne sie ein zweites Mal aufzuschreiben.
foreach (Prioritaet::cases() as $fall) {
    echo "  ", $fall->name, " steht für ", $fall->value, "\n";
}

// Aus Text wird ein Fall, wenn es einen gibt.
var_dump(Prioritaet::tryFrom("hoch"));
var_dump(Prioritaet::tryFrom("Hoch"));

try {
    Prioritaet::from("Hoch");
} catch (ValueError $fehler) {
    echo "from() sagt: ", $fehler->getMessage(), "\n";
}

Ein Enum (seit PHP 8.1) schreibt die Liste einmal auf, jeden Eintrag als einen Fall (englisch case), und macht daraus einen Typ. Prioritaet steht dann in der Typangabe, und was keine Prioritaet ist, kommt gar nicht erst herein. Das : string hinter dem Namen heißt, dass jeder Fall einen Textwert hat, und den liefert ->value. Ohne diese Angabe gäbe es die Fälle trotzdem, nur ohne einen Wert zum Speichern.

Im Beispiel stecken vier Dinge, die ein Enum mitbringt:

  • Prioritaet::Hoch ist ein Fall, und zwar immer derselbe. Ein Vergleich mit === funktioniert deshalb.
  • Prioritaet::cases() gibt alle Fälle als Array, in der Reihenfolge, in der sie im Enum stehen. Damit läuft eine Schleife über die Liste, ohne sie abzuschreiben.
  • Prioritaet::tryFrom("hoch") sucht den Fall zu einem Textwert und liefert null, wenn es keinen gibt. Das ist der Weg für Daten von außen, etwa aus einem Formular.
  • Prioritaet::from("Hoch") tut dasselbe, wirft aber einen ValueError, statt null zu liefern. Das passt zu Daten, denen du vertraust, weil ein unbekannter Wert dort ein echter Fehler ist.

Der ->name daneben ist der Name des Falls im Code (Hoch) und nicht sein Wert. In einem Protokoll ist er praktisch. Zum Speichern ist er nichts, denn ein Wert in der Datenbank soll sich nicht ändern, nur weil jemand einen Fall umbenennt.

In der Schleife über cases() siehst du im Reiter Debug fall als Prioritaet {name: "Niedrig", value: "niedrig"}. Ein Fall ist also ein Objekt mit diesen zwei Angaben.

Ein match über ein Enum ohne default

Ein match, dem ein Fall fehlt
<?php

declare(strict_types=1);

enum Prioritaet: string
{
    case Niedrig = "niedrig";
    case Normal = "normal";
    case Hoch = "hoch";
}

// Hier fehlt Prioritaet::Hoch, und zwar mit Absicht.
function beschriftung(Prioritaet $prio): string
{
    return match ($prio) {
        Prioritaet::Niedrig => "irgendwann",
        Prioritaet::Normal => "diese Woche",
    };
}

echo beschriftung(Prioritaet::Niedrig), "\n";
echo beschriftung(Prioritaet::Normal), "\n";

try {
    echo beschriftung(Prioritaet::Hoch), "\n";
} catch (\UnhandledMatchError $fehler) {
    echo "Aufgefallen: ", $fehler->getMessage(), "\n";
}

Über ein Enum lässt sich ein match schreiben, das jeden Fall behandelt und kein default braucht. Kommt später ein vierter Fall dazu, fällt jedes match auf, das ihn noch nicht kennt.

Allerdings nicht schon beim Einlesen der Datei. PHP merkt die Lücke erst, wenn wirklich ein Fall vorbeikommt, für den nichts dasteht, und wirft dann einen UnhandledMatchError. Vor dem Start meldet sich also nichts. Aber der vergessene Fall wird laut, statt still in ein default zu rutschen und dort eine harmlos aussehende Antwort zu bekommen.

Ab PHP 8.4 nennt die Meldung den Fall dabei beim Namen, im Beispiel Unhandled match case Prioritaet::Hoch, solange zend.exception_ignore_args aus ist wie hier im Kurs. PHP 8.2 und PHP 8.3 schreiben nur Unhandled match case of type Prioritaet.

Mit einem default im match über ein Enum ist dieser Fehler wieder weg. Der neue Fall bekommt dann still die Antwort des Sammelfalls, so wie "Hoch" bei den drei Konstanten oben.

In der Aufgabe werden aus drei Statuskonstanten die Fälle eines Enums.

Zum Mitnehmen

Was für alle Objekte gleich ist, gehört an die Klasse, als Konstante oder mit static. Eine feste Liste von Zuständen wird seit PHP 8.1 ein Enum, und ein match darüber ohne default meldet einen vergessenen Fall mit einem Fehler, sobald er vorbeikommt.

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.