Nach einer Rabattaktion standen im Shop falsche Listenpreise. Eine Rabattfunktion hatte das Preisobjekt verändert, das zugleich in der Artikelliste lag, und aus 19,90 Euro wurden an beiden Stellen 17,91 Euro. Gegen diese Art Fehler schützt seit PHP 8.2 eine PHP readonly class: Ein Wert, der einmal gesetzt ist, lässt sich nicht mehr überschreiben. Wie einzelne Properties mit Typ und readonly deklariert werden, zeigt das Tutorial zu Typed Properties in PHP, warum sich readonly nicht mit Hooks verträgt, das Tutorial zu den Property Hooks. Hier geht es um readonly an der ganzen Klasse, um die Regeln, die daraus folgen, und um die Stellen, an denen es im Alltag anders wirkt als erwartet.
Bei readonly hat sich von Version zu Version einiges geändert. Jede Meldung in diesem Text stammt deshalb aus einem eigenen Lauf mit PHP 8.1 bis 8.5, und bei jeder steht, wo sie gilt. Windows und Linux lieferten dieselben Texte.
Was eine PHP readonly class an jeder Property ändert
Seit PHP 8.1 kann eine einzelne Property readonly sein. Solche Readonly Properties bekommen genau einmal einen Wert, danach sind sie gesperrt. PHP 8.2 erlaubt dasselbe Schlüsselwort vor class. In einer solchen PHP readonly class gilt es für jede deklarierte Property. Beide Schreibweisen im Vergleich:
<?php
/* PHP 8.1: readonly an jeder Property */
final class Punkt81
{
public function __construct(
public readonly int $x,
public readonly int $y,
) {}
}
/* ab PHP 8.2: readonly an der Klasse */
final readonly class Punkt
{
public function __construct(
public int $x,
public int $y,
) {}
}
$p = new Punkt(1, 2);
try {
$p->x = 5;
} catch (Error $e) {
echo $e->getMessage(), PHP_EOL;
}
/* Cannot modify readonly property Punkt::$x */
Per Reflection gemessen meldet isReadOnly() für die Property x in beiden Klassen true. Die Klasse selbst gilt nur bei Punkt als readonly, ReflectionClass::isReadOnly() liefert für Punkt81 false. Eine PHP readonly class tut aber mehr, als nur Schreibarbeit zu sparen: Sie verbietet zusätzlich dynamische Properties. Der Versuch $p->z = 3 endet mit Cannot create dynamic property Punkt::$z.
Für jede Property gibt es damit genau einen Moment, in dem sie gesetzt werden darf. Das Diagramm zeigt den Lebenslauf eines Werts:
flowchart TD
A[new Geld] --> B[Property nicht initialisiert]
B -->|Zuweisung in der Klasse| C[Wert gesetzt]
B -->|Zuweisung von außen| X[Error]
C -->|jede weitere Zuweisung| X
C -->|clone| D[Kopie mit gleichen Werten]
D -->|in __clone ab PHP 8.3| E[neu setzen]
D -->|clone mit Array ab PHP 8.5| E
E --> F[wieder gesperrt]
Geänderte Werte entstehen also nur über eine Kopie, und wie das geht, hängt von der PHP-Version ab. Seit 8.4 dürfen zudem Kindklassen eine geerbte Property setzen, dazu mehr im Abschnitt über Vererbung.
Syntax im Original: readonly vor class
Die Schreibweise und die Regeln, im ersten Kommentar wörtlich aus dem Handbuch, im zweiten eigene Ergänzungen:
readonly class ClassName
{
public function __construct(
public Type $property,
) {}
}
final readonly class ClassName {}
abstract readonly class ClassName {}
$objekt = new readonly class () {}; /* 8.3+ */
/* PHP manual, quoted:
As of PHP 8.2.0, a class can be marked with the
readonly modifier. Marking a class as readonly
will add the readonly modifier to every declared
property, and prevent the creation of dynamic
properties. As neither untyped nor static
properties can be marked with the readonly
modifier, readonly classes cannot declare them
either. A readonly class can be extended if,
and only if, the child class is also a readonly
class. As of PHP 8.4.0, readonly properties are
implicitly protected(set), so may be set from
child classes. */
/* Own notes, measured in PHP 8.1 to 8.5:
the readonly keyword was introduced in PHP 8.1
for single properties, readonly classes are
supported as of PHP 8.2 (RFC readonly_classes).
A property cannot have a default value and is
initialized once from inside the class (as of
PHP 8.4 also from child classes), usually in
the constructor. Any modifications after
initialization throw an Error. Objects stored
in all properties stay mutable unless their
class is immutable too. Typical use cases are
value objects and data transfer objects. */
readonly lässt sich mit final und abstract kombinieren, die Reihenfolge der Modifier ist dabei egal; alle vier Varianten liefen im Test. Für Enums und Interfaces gibt es das Schlüsselwort nicht, readonly enum endet mit Parse error: syntax error, unexpected token "enum", expecting "abstract" or "final" or "readonly" or "class". Methoden und Konstanten einer PHP readonly class funktionieren wie gewohnt.
Die Regeln einer PHP readonly class und ihre Fehlermeldungen
Wer eine bestehende Konfigurationsklasse umstellt, setzt meist zuerst readonly davor und bekommt dann einen Fatal error nach dem anderen. Die Klasse überträgt die Regeln für readonly-Properties auf jede Property, und gewachsener Code verstößt oft gleich gegen mehrere. Gemessen in PHP 8.2 bis 8.5 mit identischem Wortlaut, nur PHP 8.5 schreibt das Attribut mit Backslash als #[\AllowDynamicProperties]:
| Regel | Meldung | Umbau |
| nur mit Typ | Readonly property Konfig::$pfad must have type | Typ ergänzen, notfalls mixed |
| kein Standardwert | Readonly property Konfig::$sprache cannot have default value | Standard im Konstruktorparameter |
| nicht statisch | Static property Zaehler::$anzahl cannot be readonly | Konstante oder static-Variable in einer Methode |
| keine dynamischen Properties | Cannot apply #[AllowDynamicProperties] to readonly class Daten | Attribut entfernen, Properties deklarieren |
| Traits nur mit readonly-Properties | Readonly class Person cannot use trait with a non-readonly property HatName::$name | im Trait readonly ergänzen |
| keine Hooks (ab 8.4) | Hooked properties cannot be readonly | Hook oder readonly, nicht beides |
| Erbe nur readonly von readonly | Non-readonly class Kind cannot extend readonly class Basis und umgekehrt Readonly class Kind cannot extend non-readonly class Basis | beide Klassen readonly oder keine |
Bei der statischen Property lohnt ein zweiter Blick. Hat sie einen Startwert wie = 0, meldet PHP zuerst cannot have default value, ohne Startwert die Meldung aus der Tabelle. Das Handbuch nennt für diesen Fall Readonly class Foo cannot declare static properties, PHP 8.2 bis 8.5 geben gemessen aber den Wortlaut aus der Tabelle aus. Wer nach der Handbuchmeldung sucht, findet seinen Fehler nicht. Die Trait-Regel greift auch bei einer typisierten Property, solange sie im Trait nicht selbst readonly ist. PHP 8.5 hängt an jeden Fatal error zusätzlich einen Stack trace an.
Statische Properties sind verboten, statische Methoden aber nicht, und darin sind sogar statische Variablen erlaubt. Eine PHP readonly class kann also durchaus Zustand mitführen:
<?php
readonly class Bestellnummer
{
public const PRAEFIX = 'B-';
public function __construct(
public int $nr,
public string $quelle = 'shop',
) {}
public static function naechste(): self
{
static $zaehler = 1000;
return new self(++$zaehler);
}
}
Bestellnummer::naechste();
$b = Bestellnummer::naechste();
echo Bestellnummer::PRAEFIX, $b->nr, ' ', $b->quelle;
/* B-1002 shop */
Der Zähler läuft weiter, obwohl die Klasse readonly ist. Das Beispiel zeigt zugleich die beiden üblichen Auswege aus der Tabelle: Der Standardwert 'shop' steht als Parameter im Konstruktor, wo er erlaubt ist, und der feste Präfix ist eine Konstante. Bevor man eine gewachsene Klasse auf eine PHP readonly class umstellt, lohnt sich ein Blick auf jede Property. Passt auch nur eine nicht zu den Regeln, bleibt readonly besser an den einzelnen Properties.
Nicht jeder Verstoß fällt schon beim Laden auf. Ein Warenkorb, der nach dem Umstellen fehlerfrei geladen wird, hat oft noch Methoden, die das eigene Array ändern. Sie scheitern erst, wenn jemand sie aufruft, also im schlimmsten Fall erst beim Kunden:
<?php
readonly class Korb
{
public function __construct(
public array $positionen = [],
) {}
public function lege(string $artikel): void
{
$this->positionen[] = $artikel;
}
public function mit(string $artikel): static
{
$neu = $this->positionen;
$neu[] = $artikel;
sort($neu);
return new static($neu);
}
}
$korb = new Korb(['Teller']);
try {
$korb->lege('Tasse');
} catch (Error $e) {
echo $e->getMessage(), PHP_EOL;
}
/* PHP 8.4 und 8.5: Cannot indirectly modify
readonly property Korb::$positionen */
$neu = $korb->mit('Tasse');
echo implode(', ', $neu->positionen), ' | ';
echo implode(', ', $korb->positionen), PHP_EOL;
/* Tasse, Teller | Teller */
Beim Laden der Klasse meldete PHP nichts, erst der Aufruf von lege() endete mit dem Fehler. PHP 8.2 und 8.3 melden Cannot modify readonly property Korb::$positionen, ab 8.4 steht indirectly in der Meldung. Mit sort($this->positionen) passierte im Test dasselbe. Solche Methoden baut man vor dem Umstellen so um, dass sie eine geänderte Kopie zurückgeben, wie mit() im Beispiel: Das Array wird lokal kopiert, geändert und an einen neuen Korb übergeben, der alte bleibt unverändert. Wer eine Klasse umstellt, sucht deshalb nach jeder Methode, die einer Property etwas zuweist oder ein Array darin verändert.
Werte im Konstruktor prüfen: warum Promotion hier scheitert
Eine Vereinsverwaltung erfasst Mitgliedsbeiträge in einer PHP readonly class und will negative Beträge im Konstruktor auf 0 setzen. Mit Konstruktor-Promotion ist das kurz geschrieben, scheitert aber:
<?php
readonly class Beitrag
{
public function __construct(public int $cent)
{
$this->cent = max(0, $cent);
}
}
try {
new Beitrag(-5);
} catch (Error $e) {
echo $e->getMessage(), PHP_EOL;
}
/* Cannot modify readonly property Beitrag::$cent */
readonly class Beitrag2
{
public int $cent;
public function __construct(int $cent)
{
$this->cent = max(0, $cent);
}
}
echo (new Beitrag2(-5))->cent, PHP_EOL;
/* 0 */
Die Promotion setzt die Property, bevor der Rumpf des Konstruktors läuft. Die Zeile mit max() ist danach schon die zweite Zuweisung und endet mit Error: Cannot modify readonly property Beitrag::$cent, in PHP 8.2 bis 8.5 ebenso wie mit einer einzelnen readonly-Property in 8.1. Die Lösung ist die zweite Klasse im Beispiel: Die Property wird normal deklariert, der Konstruktor nimmt einen gewöhnlichen Parameter entgegen, prüft ihn und setzt die Property erst danach. Promotion bleibt damit für Werte, die unverändert übernommen werden. Beides lässt sich in einer Klasse mischen, wie das Praxisbeispiel am Ende zeigt.
Was zur Laufzeit verboten ist und warum catch (Exception) nichts fängt
Ein Kollege will Schreibversuche abfangen und schreibt ein try mit catch (Exception $e). Der Fehler rauscht trotzdem durch:
<?php
readonly class Geld
{
public function __construct(public int $cent) {}
}
$g = new Geld(100);
try {
$g->cent = 50;
} catch (Exception $e) {
echo 'gefangen', PHP_EOL;
}
/* Fatal error: Uncaught Error: Cannot modify
readonly property Geld::$cent */
Alle Verstöße gegen eine PHP readonly class werfen ein Error, keine Exception. Im Test lieferte $e instanceof Exception false, und der Code nach dem catch lief nicht mehr. Wer solche Fehler wirklich abfangen muss, nimmt catch (Error $e) oder catch (Throwable $e). Besser ist eine Klasse, die gar nicht zum Schreibversuch einlädt, weil sie eine Methode für geänderte Kopien anbietet.
Eine zweite Falle trifft Testsuiten, die Fehlermeldungen wörtlich vergleichen. PHP 8.4 hat mehrere Texte geändert, und wer von 8.3 aktualisiert, sieht plötzlich rote Tests, obwohl der Code unverändert ist. Gemessen an einer PHP readonly class namens Bestellung:
| Versuch | PHP 8.2 und 8.3 | PHP 8.4 und 8.5 |
$b->nummer = 1002, auch ++ | Cannot modify readonly property Bestellung::$nummer | gleich |
$b->positionen[] = 'Teller' | Cannot modify readonly property Bestellung::$positionen | Cannot indirectly modify readonly property Bestellung::$positionen |
$r = &$b->nummer | Cannot modify readonly property Bestellung::$nummer | Cannot indirectly modify readonly property Bestellung::$nummer |
| von außen erstmals setzen | Cannot initialize readonly property Spaeter::$wert from global scope | Cannot modify protected(set) readonly property Spaeter::$wert from global scope |
unset($b->nummer) | Cannot unset readonly property Bestellung::$nummer | gleich |
foreach ($b as &$v) | Cannot acquire reference to readonly property Bestellung::$nummer | gleich |
| lesen vor dem Setzen | Typed property Spaeter::$wert must not be accessed before initialization | gleich |
Auch ein erneuter Aufruf von $b->__construct(...) endet mit Cannot modify readonly property, ein Konstruktor lässt sich also nicht als Setter missbrauchen. Tests prüfen deshalb besser die Fehlerklasse Error und einen stabilen Teil der Meldung wie readonly property statt des ganzen Satzes.
Objekte in readonly Properties bleiben veränderlich
Eine Terminverwaltung legt zwei Termine aus demselben Startdatum an. Für den zweiten wird das Startdatum um eine Woche verschoben, und plötzlich steht auch der erste Termin eine Woche später, obwohl Termin eine PHP readonly class ist:
<?php
readonly class Termin
{
public function __construct(
public DateTime $beginn,
) {}
}
$start = new DateTime('2026-11-12 10:00');
$erster = new Termin($start);
$start->modify('+1 week');
$zweiter = new Termin($start);
echo $erster->beginn->format('d.m.'), PHP_EOL;
/* 19.11., der erste Termin ist mitgewandert */
readonly class Abo
{
public function __construct(
public DateTimeImmutable $ende,
) {}
public function verlaengertFalsch(): static
{
$this->ende->modify('+1 month');
return new static($this->ende);
}
public function verlaengert(): static
{
$neu = $this->ende->modify('+1 month');
return new static($neu);
}
}
$abo = new Abo(new DateTimeImmutable('2026-11-30'));
echo $abo->verlaengertFalsch()->ende->format('d.m.Y');
/* 30.11.2026, nichts verlängert */
echo ' ', $abo->verlaengert()->ende->format('d.m.Y');
/* 30.12.2026 */
readonly schützt die Zuweisung an die Property, nicht das Objekt dahinter. Beide Termine zeigen auf dasselbe DateTime, und dessen modify() wirkt auf beide. Genauso nahm im Test ein ArrayObject in einer readonly-Property neue Einträge an. Bei Objekten in einem readonly-Array blockiert PHP nur den direkten Weg $b->positionen[0]->menge = 5, über eine Zwischenvariable oder in einem foreach ließ sich die Menge trotzdem ändern. Arrays selbst sind dagegen ganz geschützt, weil sie Werte sind.
Die Lösung sind Typen, die selbst unveränderlich sind, für Datumswerte also DateTimeImmutable. Den Unterschied zwischen beiden Klassen erklärt das Tutorial zu PHP DateTime. Beim Umstellen lauert die zweite Falle aus dem Beispiel: modify() verändert ein DateTimeImmutable nicht, sondern gibt ein neues Objekt zurück. Wer das Ergebnis nicht verwendet, verlängert gar nichts, das Abo endet weiter am 30.11.2026. PHP 8.4 und älter schweigen dazu. Erst PHP 8.5 meldet gemessen:
Warning: The return value of method DateTimeImmutable::modify() should either be used or intentionally ignored by casting it as (void), as DateTimeImmutable::modify() does not modify the object itself
In eine PHP readonly class gehören deshalb Zahlen, Zeichenketten, Arrays und Objekte, die selbst unveränderlich sind. Wer ein veränderliches Objekt übernehmen muss, deklariert die Property ohne Promotion und setzt im Konstruktor $this->beginn = clone $beginn;. Im Test blieb der Termin so beim 12.11., auch als das Startdatum danach verschoben wurde.
Geänderte Kopien: with-Methoden, __clone() und clone() in PHP 8.5
Auch eine PHP readonly class braucht einen Weg zu geänderten Werten. Üblich sind Methoden wie mitCent(), die eine Kopie mit neuem Wert liefern. Der erste Versuch klont das Objekt und weist dann zu, und das scheitert:
<?php
readonly class Geld
{
public function __construct(
public int $cent,
public string $waehrung,
) {}
public function mitCent(int $cent): static
{
return new static($cent, $this->waehrung);
}
public function mitCentFalsch(int $cent): static
{
$kopie = clone $this;
$kopie->cent = $cent;
return $kopie;
}
}
$preis = new Geld(1990, 'EUR');
echo $preis->mitCent(1490)->cent, PHP_EOL;
/* 1490 */
try {
$preis->mitCentFalsch(990);
} catch (Error $e) {
echo $e->getMessage(), PHP_EOL;
}
/* Cannot modify readonly property Geld::$cent */
Die Kopie übernimmt die Property bereits gesetzt, jede weitere Zuweisung ist verboten. Der Weg über new static() funktioniert dagegen in allen Versionen ab 8.2. Für Klassen mit vielen Properties wird er allerdings lang, weil jeder Wert neu übergeben werden muss.
Seit PHP 8.3 darf eine Property innerhalb von __clone() neu gesetzt werden. Das braucht man vor allem für tiefe Kopien, wenn das Objekt selbst ein veränderliches Objekt enthält:
<?php
readonly class Dokument
{
public function __construct(
public string $titel,
public DateTime $geaendert,
) {}
public function __clone(): void
{
$this->geaendert = clone $this->geaendert;
}
}
try {
$alt = new DateTime('2026-01-01');
$d = new Dokument('Angebot', $alt);
$k = clone $d;
$k->geaendert->modify('+1 year');
echo $d->geaendert->format('Y'), ' ';
echo $k->geaendert->format('Y'), PHP_EOL;
} catch (Error $e) {
echo $e->getMessage(), PHP_EOL;
}
/* ab PHP 8.3: 2026 2027
PHP 8.2: Cannot modify readonly property
Dokument::$geaendert */
Der eleganteste Weg kam mit PHP 8.5: clone() nimmt als zweites Argument ein Array mit neuen Werten.
<?php
readonly class Geld
{
public function __construct(
public int $cent,
public string $waehrung,
) {}
public function mitCent(int $cent): static
{
return clone($this, ['cent' => $cent]);
}
}
$preis = new Geld(1990, 'EUR');
echo $preis->mitCent(1490)->cent, PHP_EOL;
/* 1490 */
try {
clone($preis, ['cent' => 1]);
} catch (Error $e) {
echo $e->getMessage(), PHP_EOL;
}
/* Cannot modify protected(set) readonly property
Geld::$cent from global scope */
Ältere Versionen können diese Datei gar nicht laden, PHP 8.4 meldet Parse error: syntax error, unexpected token ",". Von außerhalb der Klasse aufgerufen, scheitert clone() an der Sichtbarkeit, wie im Beispiel. Ein falscher Typ meldet TypeError: Cannot assign string to property Geld::$cent of type int, ein unbekannter Name Cannot create dynamic property Geld::$rabatt. Hat die Klasse ein eigenes __clone(), läuft es zuerst, danach werden die übergebenen Werte gesetzt und gewinnen. Für Bibliotheken, die noch PHP 8.2 unterstützen, bleibt new static() die sichere Wahl, __clone() nur für tiefe Kopien.
Aus Datenbank und Cache füllen: PDO, Reflection, unserialize()
Ein Reiseportal liest Kunden mit fetchObject() und will sie direkt in readonly-Datenobjekte füllen, wie es das von gewöhnlichen Klassen kennt. Mit einer PHP readonly class und Konstruktor-Promotion geht das schief. Das Beispiel nutzt SQLite im Arbeitsspeicher, damit es ohne Datenbankserver läuft:
<?php
readonly class KundeDto
{
public function __construct(
public int $id,
public string $name,
) {}
}
readonly class KundeZeile
{
public int $id;
public string $name;
}
$db = new PDO('sqlite::memory:');
$db->setAttribute(
PDO::ATTR_ERRMODE,
PDO::ERRMODE_EXCEPTION
);
$db->exec('CREATE TABLE kunde (id INT, name TEXT)');
$db->exec("INSERT INTO kunde VALUES (1, 'Ina')");
$sql = 'SELECT id, name FROM kunde';
try {
$db->query($sql)->fetchObject(
KundeDto::class,
[0, '']
);
} catch (Error $e) {
echo $e->getMessage(), PHP_EOL;
}
/* Cannot modify readonly property KundeDto::$id */
$zeile = $db->query($sql)->fetch(PDO::FETCH_ASSOC);
$k1 = new KundeDto(...$zeile);
echo $k1->id, ' ', $k1->name, PHP_EOL;
/* 1 Ina */
$k2 = $db->query($sql)->fetchObject(KundeZeile::class);
echo $k2->id, ' ', $k2->name, PHP_EOL;
/* 1 Ina */
PDO schreibt die Spalten zuerst in die Properties und ruft danach den Konstruktor auf. Der Konstruktor trifft dann eine bereits gesetzte Property und meldet Cannot modify readonly property KundeDto::$id. Ohne Konstruktorargumente kommt stattdessen ArgumentCountError: Too few arguments to function, und mit PDO::FETCH_PROPS_LATE scheitert umgekehrt das Schreiben der Spalten. Steht im SELECT eine Spalte mehr, als die Klasse Properties hat, meldet PHP Cannot create dynamic property. Zwei Wege funktionieren, beide im Beispiel: die Zeile als Array holen und mit benannten Argumenten an den Konstruktor geben, oder eine readonly-Klasse ganz ohne Konstruktor, deren Properties PDO einmal setzt. Welche Abrufarten PDO sonst kennt, zeigt das Tutorial zu PHP PDO.
Beim ersten Weg kommt es auf die Typen an. Kommen Zahlen als Zeichenkette an, etwa aus JSON oder einem Formular, wandelt PHP ohne strict_types sie still um. Mit declare(strict_types=1) endet new Kunde(...$daten) dagegen mit TypeError: Kunde::__construct(): Argument #1 ($id) must be of type int, string given. Das Mapping gehört dann an eine Stelle, die die Typen ausdrücklich umwandelt.
Bibliotheken zum Serialisieren erzeugen Objekte oft ohne Konstruktor und setzen die Felder einzeln. Das geht auch bei einer PHP readonly class, aber nur einmal:
<?php
readonly class Kunde
{
public function __construct(
public int $id,
public string $name,
) {}
}
function fuellen(string $klasse, array $daten): object
{
$r = new ReflectionClass($klasse);
$o = $r->newInstanceWithoutConstructor();
foreach ($daten as $feld => $wert) {
$r->getProperty($feld)->setValue($o, $wert);
}
return $o;
}
$daten = ['id' => 7, 'name' => 'Ina'];
$k = fuellen(Kunde::class, $daten);
echo $k->id, ' ', $k->name, PHP_EOL;
/* 7 Ina */
$feld = new ReflectionProperty(Kunde::class, 'name');
var_dump($feld->isReadOnly());
/* bool(true) */
try {
$feld->setValue($k, 'Uwe');
} catch (Error $e) {
echo $e->getMessage(), PHP_EOL;
}
/* Cannot modify readonly property Kunde::$name */
ReflectionProperty::setValue() darf eine noch leere Property einmal setzen, ein zweites Mal endet wie jede andere Zuweisung. Im Test füllten außerdem Closure::bind() im Kontext der Klasse und unserialize() ein readonly-Objekt, und danach war es bei beiden Wegen wie jedes andere gesperrt. Eine Bibliothek fragt vorher isReadOnly() ab und behandelt jede PHP readonly class als einmal befüllbar.
Eine Sonderform ist das späte Laden. Eine Property darf vor ihrer ersten Zuweisung aus der eigenen Klasse heraus mit unset() entfernt werden. Dann ruft PHP beim ersten Lesen __get() auf, und dort kann der Wert gesetzt werden:
<?php
readonly class Bericht
{
public string $inhalt;
public function __construct(public int $id)
{
unset($this->inhalt);
}
public function __get(string $name): mixed
{
echo 'lade ', $name, PHP_EOL;
$this->inhalt = 'Bericht ' . $this->id;
return $this->inhalt;
}
}
$b = new Bericht(3);
echo $b->inhalt, PHP_EOL;
echo $b->inhalt, PHP_EOL;
/* lade inhalt
Bericht 3
Bericht 3 */
Die Ausgabe lade inhalt erscheint nur beim ersten Zugriff, danach liest PHP die gesetzte Property direkt. So lassen sich teure Werte erst bei Bedarf berechnen, ohne auf die PHP readonly class zu verzichten.
Vererbung und Versionen: von PHP 8.1 über PHP 8.2 bis 8.5
Eine Agentur entwickelt auf PHP 8.4, ein Teil der Kunden läuft noch auf 8.3. Nach einem Update fiel auf einem dieser Server eine Seite aus, die lokal einwandfrei lief. Die Ursache war eine Kindklasse, die eine readonly-Property ihrer Elternklasse setzt:
<?php
readonly class Basis
{
public int $id;
}
readonly class Mitglied extends Basis
{
public function __construct(int $id)
{
$this->id = $id;
}
}
readonly class Person
{
public function __construct(public int $id) {}
}
readonly class Kunde extends Person
{
public function __construct(
int $id,
public string $name,
) {
parent::__construct($id);
}
}
try {
echo (new Mitglied(7))->id, PHP_EOL;
} catch (Error $e) {
echo $e->getMessage(), PHP_EOL;
}
/* PHP 8.4 und 8.5: 7
PHP 8.2 und 8.3: Cannot initialize readonly
property Basis::$id from scope Mitglied */
$k = new Kunde(8, 'Ina');
echo $k->id, ' ', $k->name, PHP_EOL;
/* 8 Ina, in PHP 8.2 bis 8.5 */
Bis PHP 8.3 durfte nur die Klasse, die eine readonly-Property deklariert, sie auch setzen. Seit 8.4 sind readonly-Properties implizit protected(set), Kindklassen dürfen sie also initialisieren. Wer auch ältere Server bedient, setzt die Property im Konstruktor der Elternklasse und ruft ihn mit parent::__construct() auf, wie die zweite Kindklasse im Beispiel; das lief in 8.2 bis 8.5 gleich. Für die Vererbung selbst gilt die Regel aus der Tabelle oben: Eine PHP readonly class kann nur von einer readonly-Klasse erben und nur readonly-Kinder haben.
Ähnlich verhält es sich mit anonymen Klassen. new readonly class gibt es erst seit PHP 8.3:
<?php
$konfig = new readonly class('de', 30) {
public function __construct(
public string $sprache,
public int $timeout,
) {}
};
echo $konfig->sprache, ' ', $konfig->timeout, PHP_EOL;
try {
$konfig->timeout = 60;
} catch (Error $e) {
echo $e->getMessage(), PHP_EOL;
}
/* de 30
Cannot modify readonly property
class@anonymous::$timeout */
PHP 8.2 bricht hier mit Parse error: syntax error, unexpected token "readonly" ab, und zwar für die ganze Datei, nicht nur für die eine Zeile. Die wichtigsten Unterschiede der Versionen, alle gemessen:
| Funktion | 8.1 | 8.2 | 8.3 | 8.4 | 8.5 |
readonly an Properties | ja | ja | ja | ja | ja |
readonly class | Parse error | ja | ja | ja | ja |
neu setzen in __clone() | Error | Error | ja | ja | ja |
new readonly class | Parse error | Parse error | ja | ja | ja |
| Kindklasse setzt geerbte Property | Error | Error | Error | ja | ja |
clone($obj, [...]) | Parse error | Parse error | Parse error | Parse error | ja |
neue Meldungen mit indirectly und protected(set) | nein | nein | nein | ja | ja |
Warning bei verworfenem modify() | nein | nein | nein | nein | ja |
Den Unterschied zwischen 8.1 und 8.2 sieht man schon am ersten Zeichen: PHP 8.1 kennt readonly vor class nicht und meldet Parse error: syntax error, unexpected token "readonly", expecting end of file. Code mit einer PHP readonly class gehört deshalb gegen die kleinste Version getestet, auf der er laufen soll, und die Mindestversion gehört in die composer.json.
Bleibt die Frage, wann die ganze Klasse readonly sein sollte. Wenn nach dem Konstruktor jede Property fest ist und keine gewöhnliche Klasse davon erben muss, ist die PHP readonly class die kürzeste und strengste Form. Hat die Klasse auch veränderliche Felder, bleibt readonly an den einzelnen Properties. Soll ab 8.4 nur das Schreiben von außen verhindert werden, reicht private(set), und wenn beim Lesen oder Schreiben gerechnet oder geprüft wird, sind Property Hooks das passende Werkzeug.
Praxis: Geldbeträge als PHP readonly class
Zurück zum Preisfehler aus der Einleitung. So sah der Code aus, der den Listenpreis verändert hat:
<?php
final class Preis
{
public function __construct(public int $cent) {}
}
function rabatt(Preis $p, int $prozent): Preis
{
$neu = intdiv($p->cent * (100 - $prozent), 100);
$p->cent = $neu;
return $p;
}
$liste = ['tasse' => new Preis(1990)];
$aktion = rabatt($liste['tasse'], 10);
echo $liste['tasse']->cent, ' ', $aktion->cent;
/* 1791 1791, der Listenpreis ist weg */
Objekte werden in PHP als Verweis weitergegeben. rabatt() rechnet deshalb im selben Objekt, das auch in der Liste steht, und überschreibt den Listenpreis. Kein Fehler, keine Warnung, nur ein falscher Preis im Shop. Die Lösung ist ein Wertobjekt, auf Englisch Value Object, gebaut als PHP readonly class, das sich nach dem Anlegen nicht mehr ändern lässt:
<?php
final readonly class Betrag
{
public int $cent;
public function __construct(
int $cent,
public string $waehrung = 'EUR',
) {
if ($cent < 0) {
throw new InvalidArgumentException(
'Betrag darf nicht negativ sein'
);
}
$this->cent = $cent;
}
public function minusProzent(int $prozent): static
{
$rest = $this->cent * (100 - $prozent);
return new static(
intdiv($rest, 100),
$this->waehrung
);
}
public function plus(Betrag $b): static
{
if ($b->waehrung !== $this->waehrung) {
throw new LogicException(
'Währungen passen nicht zusammen'
);
}
return new static(
$this->cent + $b->cent,
$this->waehrung
);
}
public function gleich(Betrag $b): bool
{
return $this == $b;
}
public function anzeigen(): string
{
$euro = number_format(
$this->cent / 100, 2, ',', '.'
);
return $euro . ' ' . $this->waehrung;
}
}
$liste = ['tasse' => new Betrag(1990)];
$aktion = $liste['tasse']->minusProzent(10);
echo $liste['tasse']->anzeigen(), PHP_EOL;
/* 19,90 EUR */
echo $aktion->anzeigen(), PHP_EOL;
/* 17,91 EUR */
$summe = $aktion->plus(new Betrag(500));
echo $summe->anzeigen(), PHP_EOL;
/* 22,91 EUR */
var_dump($summe->gleich(new Betrag(2291)));
/* bool(true) */
try {
$aktion->cent = 1;
} catch (Error $e) {
echo $e->getMessage(), PHP_EOL;
}
/* Cannot modify readonly property Betrag::$cent */
try {
new Betrag(-1);
} catch (InvalidArgumentException $e) {
echo $e->getMessage(), PHP_EOL;
}
/* Betrag darf nicht negativ sein */
Die Klasse setzt alles um, was die vorigen Abschnitte gezeigt haben. Der Betrag in Cent ist eine normal deklarierte Property, damit der Konstruktor ihn zuerst prüfen kann; die Währung wird per Promotion übernommen, weil es an ihr nichts zu prüfen gibt. minusProzent() und plus() verändern nichts, sondern liefern jeweils ein neues Objekt, so wie new static() im Abschnitt über Kopien. plus() verweigert das Addieren verschiedener Währungen mit einer eigenen Exception. Für den Vergleich reicht ==, denn zwei Objekte derselben Klasse mit gleichen Werten gelten damit als gleich. === prüft dagegen, ob es dasselbe Objekt ist, und lieferte im Test false.
Die Ausgaben im Kommentar waren in PHP 8.2 bis 8.5 identisch. Die Klasse ist final, weil eine Unterklasse ohnehin wieder readonly sein müsste und ein Wertobjekt keine Ableitungen braucht. Nach demselben Muster lassen sich Mengen, Zeiträume oder Kundennummern als PHP readonly class bauen, überall dort, wo ein Wert an mehreren Stellen verwendet wird und an keiner davon heimlich geändert werden darf.
Fazit
Eine PHP readonly class macht seit PHP 8.2 jede Property schreibgeschützt und verbietet dynamische Properties. Die Regeln sind streng: Properties brauchen einen Typ, dürfen weder statisch sein noch einen Standardwert haben, und Vererbung funktioniert nur zwischen readonly-Klassen. Werte, die geprüft werden sollen, gehören nicht in die Konstruktor-Promotion.
Im Alltag zählen vor allem die Stellen, an denen eine PHP readonly class nicht schützt oder anders wirkt: Objekte in Properties bleiben veränderlich, catch (Exception) fängt die Fehler nicht, PDO scheitert an Klassen mit Promotion, und geänderte Kopien entstehen je nach Version über new static(), __clone() ab 8.3 oder clone() mit Werten ab 8.5. Wer diese Punkte kennt und gegen seine kleinste PHP-Version testet, bekommt Objekte, die sich nicht mehr heimlich ändern.