Abschnitt 13 · Lektion 2
Statisch, Konstanten, Enums
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
<?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
<?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
<?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
<?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::Hochist 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 liefertnull, 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 einenValueError, stattnullzu 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
<?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, 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.