Navigation
 Startseite
 Fachbücher
 Anzeigenmarkt
 Forum
 Webmaster News
 Script Newsletter
 Push Meldungen
 Kontakt
 Script Installation
 Php
 Php Tutorials
 Lernpfade
 Webhoster Vergleich
 Impressum

Community-Bereich
 kostenlos Registrieren
 Anmelden
 Benutzerliste

Script Datenbank
 Script Archiv
 Script Top 20
 Screenshots
 Testberichte

Suche
 

Unsere Php Scripts
 Counter Script
 Umfrage Script
 Bilder Upload Script
 Terminverwaltung
 Simple PHP Forum
 RSS Grabber

Tools und Generatoren
 .htpasswd Generator
 md5 Generator
 base64 Generator
 Markdown to HTML
 Colorpicker
 Unix timestamp Tool
 Unit Test Generator
 TLD Liste
 Webkatalog‑Verzeichnis

Webspace-Mieten.d...
Webhosting mit Plesk aus Erfurt: Vier Webspace-Pak...
https://www.Webspace-Mieten.de
Hosterplus.de
Bekommen Sie Speicherplatz (Webspace), Domains und...
https://www.Hosterplus.de
 
 
 

PHP readonly class: Alle Properties ab PHP 8.2 schützen

Sie befinden sich: Home > Php Tutorial > PHP readonly class: Alle Pr...

PHP readonly class: Alle Properties ab PHP 8.2 schützen
Veröffentlicht am:
17.11.2026
Hits / Besucher:
16
Sprache:
  Deutsch
Tutorial Art:
eigenes
Merkliste:
 
Beschreibung

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.

Illustration zum Tutorial: PHP readonly class: Alle Properties ab PHP 8.2 schützen

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.

 

Tags:

 

 

Kommentare (0)

Noch keine Kommentare. Sei der Erste!

Melde dich an, um einen Kommentar zu schreiben.
Bücherregal mit drei Büchern: 'PHP 4 - Grundlagen und Profiwissen' von Hanser Verlag, 'Webdesign in a Nutshell' von O'Reilly Verlag, und 'Webgestaltung' von Galileo Computing.