Was bringt PHP 8.4?

Mit PHP 8.4 hat die Community wieder einige sinnvolle Verbesserungen geliefert – keine Revolution, aber eine Reihe von Features, die den Entwickleralltag spürbar angenehmer machen. Von Property Hooks über HTML5-Support bis hin zu Performance-Optimierungen: Es lohnt sich, einen Blick auf die Neuerungen zu werfen.

Im Folgenden stelle ich die wichtigsten Features vor – mit Beispielen, wie man sie direkt einsetzen kann.

Property Hooks – Getter und Setter ohne Boilerplate

Bisher musste man für Getter und Setter in PHP oft private Properties mit entsprechenden Methoden kombinieren. Das war funktional, aber oft unnötig verbose. Mit PHP 8.4 kommen Property Hooks – eine elegante Möglichkeit, Logik direkt an Properties zu hängen.

class User
{
    public string $firstName;
    public string $lastName;

    public string $fullName {
        get => $this->firstName . ' ' . $this->lastName;
    }
}

$user = new User();
$user->firstName = 'Max';
$user->lastName = 'Mustermann';
echo $user->fullName; // Max Mustermann

Der Vorteil: Kein Getter/Setter-Boilerplate mehr, und die Logik bleibt direkt am Property. Besonders praktisch, wenn man berechnete Werte oder Transformationen braucht – zum Beispiel beim Formatieren von Preisen oder beim Normalisieren von URLs.

Man kann auch set-Hooks nutzen, um Validierung direkt beim Setzen durchzuführen:

class Product
{
    public float $price {
        set {
            if ($value < 0) {
                throw new ValueError('Preis darf nicht negativ sein');
            }
            $this->price = $value;
        }
    }
}

Array-Funktionen mit array_find() und array_find_key()

Wer oft mit Arrays arbeitet, kennt das Problem: Man will das erste Element finden, das eine bestimmte Bedingung erfüllt – und muss dafür entweder eine Schleife bauen oder array_filter() mit array_shift() kombinieren.

PHP 8.4 bringt endlich array_find() und array_find_key():

$users = [
    ['id' => 1, 'name' => 'Anna'],
    ['id' => 2, 'name' => 'Ben'],
    ['id' => 3, 'name' => 'Clara'],
];

$user = array_find($users, fn($u) => $u['id'] === 2);
// ['id' => 2, 'name' => 'Ben']

$key = array_find_key($users, fn($u) => $u['name'] === 'Clara');
// 2

Das macht Code deutlich lesbarer und spart unnötige Zwischenschritte. Besonders in Situationen, wo man mit größeren Datensätzen arbeitet – etwa bei API-Responses oder Datenbank-Results – ist das eine echte Erleichterung.

HTML5-Support für DOM-Extension

Die DOM-Extension in PHP war schon länger vorhanden, aber HTML5-Parsing war immer eine Schwachstelle. PHP 8.4 bringt neue Klassen: Dom\HTMLDocument und Dom\XMLDocument – mit vollständigem HTML5-Support.

$html = '
Titel
Text
';

$doc = Dom\HTMLDocument::createFromString($html);
$headline = $doc->querySelector('h1');
echo $headline->textContent; // Titel

Das funktioniert endlich auch mit modernem HTML – inklusive <section>, <article>, <nav> und allen anderen semantischen Tags. Wer bisher mit DOMDocument gekämpft hat, wird den Unterschied sofort merken.

Besonders nützlich beim Scraping, beim Parsen von E-Mail-Templates oder beim Aufbereiten von Content aus externen Quellen.

Asymmetrische Visibility für Properties

Ein weiteres Feature, das vor allem bei DTOs und Value Objects praktisch ist: Man kann jetzt public read, aber private/protected write definieren.

class Order
{
    public private(set) string $orderId;

    public function __construct(string $orderId)
    {
        $this->orderId = $orderId;
    }
}

$order = new Order('ORD-12345');
echo $order->orderId; // ORD-12345
$order->orderId = 'neu'; // Fehler: Property ist read-only

Damit lässt sich Unveränderlichkeit erzwingen, ohne auf readonly Properties zurückgreifen zu müssen – und man bleibt flexibel für interne Änderungen innerhalb der Klasse.

Lazy Objects – Verzögertes Laden von Objekten

PHP 8.4 führt Lazy Objects ein – ein Konzept, das vor allem bei ORMs wie Doctrine schon lange im Einsatz ist, jetzt aber nativ unterstützt wird.

Die Idee: Ein Objekt wird erst dann vollständig initialisiert, wenn man tatsächlich darauf zugreift. Das spart Ressourcen, wenn man viele Objekte laden muss, aber nur einen Bruchteil davon wirklich braucht.

$user = ReflectionClass::newLazyProxy(User::class, function ($proxy) {
    // Wird erst ausgeführt, wenn auf $user zugegriffen wird
    return new User(loadFromDatabase());
});

echo $user->name; // Jetzt wird geladen

Für Performance-kritische Anwendungen – etwa im E-Commerce oder bei APIs mit vielen Relationen – kann das einen spürbaren Unterschied machen.

Performance-Verbesserungen

Wie bei jedem Release hat das PHP-Team auch an der Performance geschraubt. Besonders bei JIT (Just-in-Time Compilation) und bei der Speicherverwaltung gibt es Optimierungen.

In Benchmarks zeigt sich vor allem bei rechenintensiven Operationen – etwa bei großen Arrays oder komplexen String-Manipulationen – eine Verbesserung von etwa 5–10 %. Nicht weltbewegend, aber für Anwendungen mit hohem Durchsatz durchaus relevant.

Deprecations und Breaking Changes

Wie immer gibt es auch Features, die als deprecated markiert wurden – etwa implizite nullable Parameter oder veraltete Array-Offset-Zugriffe. Wer von PHP 8.3 upgradet, sollte die offizielle Migration-Anleitung durchgehen.

In der Praxis sollten die meisten modernen Codebases aber ohne größere Anpassungen funktionieren – solange man bereits auf PHP 8.x unterwegs ist.

Fazit

PHP 8.4 ist kein Quantensprung, aber eine solide Evolution. Property Hooks, HTML5-Support und die neuen Array-Funktionen machen den Code sauberer und lesbarer. Lazy Objects und asymmetrische Visibility bringen mehr Kontrolle – ohne zusätzliche Komplexität.

Wer produktiv mit PHP arbeitet, sollte sich die Neuerungen ansehen. Besonders Property Hooks und array_find() werden sich schnell als Standard etablieren – und der Code wird dadurch spürbar aufgeräumter.

👉 Update lohnt sich – wie immer gilt: Erst in Staging testen, dann produktiv rollout.