Neuerungen in PHP 8.2: Ein umfassender Überblick

Die Neuerungen in PHP 8.2. PHP, die beliebte serverseitige Skriptsprache, hat sich im Laufe der Jahre ständig weiterentwickelt, um den Anforderungen moderner Webentwicklung gerecht zu werden. Mit jeder neuen Version werden nicht nur Fehler behoben und die Performance verbessert, sondern auch neue Funktionen und Verbesserungen eingeführt, die die Sprache moderner, sicherer und effizienter machen.

Die Neuerungen in PHP 8.2 sind keine Ausnahmen. Diese Version bringt eine Fülle von Neuerungen und Verbesserungen mit sich, die sowohl für Entwickler als auch für Endbenutzer von Vorteil sind. Von neuen String-Funktionen über verbesserte Typsysteme bis zu Performance-Optimierungen – PHP 8.2 hat viel zu bieten.

In diesem Artikel werden wir uns detailliert mit den Neuerungen in PHP 8.2 beschäftigen. Wir werden die wichtigsten neuen Funktionen und Änderungen vorstellen, ihre Anwendung in der Praxis zeigen und Tipps geben, wie Sie das Beste aus dieser neuen Version herausholen können.

Egal, ob Sie ein erfahrener PHP-Entwickler sind oder gerade erst mit der Sprache beginnen, es gibt in PHP 8.2 sicherlich etwas Neues und Aufregendes für Sie zu entdecken. Lassen Sie uns also ohne Weiteres in die spannende Welt der Neuerungen in PHP 8.2 eintauchen!

Neuerungen in PHP 8.2 neue Funktionen

Fangen wir mit den Neuerungen in PHP 8.2, die die Funktionen beträfen.

Die neuen readonly Klasse

Mit der Einführung von der Neuerungen in PHP 8.2 wurde das Konzept der readonly Eigenschaften weiterentwickelt und auf Klassenebene erweitert. Während PHP 8.1 bereits ermöglichte, einzelne Klasseneigenschaften als readonly zu deklarieren, geht PHP 8.2 noch einen Schritt weiter und ermöglicht es, ganze Klassen als readonly zu markieren.

Was sind readonly Klassen?

Eine readonly Klasse ist eine Klasse, deren Instanzen nach der Erstellung nicht mehr verändert werden können. Das bedeutet, dass alle Eigenschaften dieser Klasse automatisch als readonly behandelt werden, sobald ein Objekt der Klasse instanziiert wurde.

Mit PHP 8.1 mussten alle Klasseneigenschaften einzeln als readonly deklariert werden.

class Benutzer {
    public readonly string $name;
    public readonly int $alter;
}

Jetzt reicht es nur, die Klasse readonly zu deklarieren.

Wie verwendet man readonly Klassen?

Die Deklaration einer readonly Klasse ist einfach und erfordert nur das Voranstellen des Schlüsselworts readonly vor das Schlüsselwort class:

readonly class Benutzer {
    public string $name;
    public int $alter;

    public function __construct(string $name, int $alter) {
        $this->name = $name;
        $this->alter = $alter;
    }
}

$benutzer = new Benutzer("Anna", 30);
// Der folgende Code würde einen Fehler auslösen:
// $benutzer->name = "Lisa";

Es ist möglich, eine readonly Klasse ohne definierte Eigenschaften zu erstellen. Dies verhindert die Zuweisung dynamischer Eigenschaften, wobei Unterklassen dennoch in der Lage sind, ihre readonly Eigenschaften klar zu definieren.

Weiterhin dürfen readonly Klassen ausschließlich typisierte Eigenschaften besitzen. Diese Regelung trifft ebenso auf die Definition einzelner readonly Eigenschaften zu.

Falls eine strikte Typisierung nicht möglich ist, kann die mixed type-Eigenschaft als Alternative genutzt werden.

Ein Versuch, eine readonly Klasse ohne typisierte Eigenschaft zu erstellen, resultiert in einem fatal Fehler.

readonly class User {
   public $name;
}
Fatal error: Readonly property User::$name must have type in ... on line ... 

Zudem ist es nicht möglich, das readonly Schlüsselwort für bestimmte PHP-Strukturen zu verwenden:

• Enums (weil sie keine Eigenschaften haben)
• Traits
• Interfaces

Ein Versuch, eines dieser Elemente mit readonly zu definieren, resultiert in einem Parse-Fehler:

readonly interface Post {}
Parse error: syntax error, unexpected token "interface", expecting "abstract" or "final" or "readonly" or "class" in ... on line ...

Wie bei allen PHP-Schlüsselwörtern ist die Groß- und Kleinschreibung beim readonly Schlüsselwort nicht relevant.

In PHP 8.2 werden zudem dynamische Eigenschaften nicht mehr unterstützt. Es ist nicht möglich, das Hinzufügen dynamischer Eigenschaften zu einer Klasse komplett zu unterbinden. Wenn du jedoch versuchst, dies bei einer readonly Klasse zu tun, wird ein schwerwiegender Fehler ausgelöst:

Fatal error: Readonly property Test::$test must have type in ... on line ...

Die Anerkennung von true, false und null als unabhängige Typen

Bereits vorhandene skalare Typen in PHP, wie int, string und bool, wurden in PHP 8.0 durch die Einführung von Union-Typen ergänzt. Diese erlauben es, dass Variablen unterschiedliche Typen annehmen können. Obwohl der gleiche RFC die Integration von false und null in Union-Typen zuließ, war ihre Verwendung als separate Typen nicht gestattet.

Ein Versuch, false oder null als unabhängige Typen zu definieren – außerhalb eines Union-Typs – resultierte in einem schwerwiegenden Fehler:

function spam(): null {}
function eggs(): false {}
Fatal error: Null can not be used as a standalone type in ... on line ...
Fatal error: False can not be used as a standalone type in ... on line ...

Die Neuerungen in PHP 8.2 beinhalten die Akzeptanz von false und null als separate Typen, um solche Fehler zu vermeiden. Dies erweitert und verfeinert das Typensystem von PHP und ermöglicht präzisere Deklarationen von Rückgabewerten, Parametern und Eigenschaften.

Zudem fehlte in PHP bislang der Typ true, welcher als logisches Pendant zum Typ false angesehen wurde. Mit den Neuerungen in PHP 8.2 wird dieser Mangel behoben und der Typ true hinzugefügt. Ähnlich wie false erzwingt auch true keine strikte Typisierung.

Die Typen true und false können als spezialisierte Varianten des bool-Typs in PHP betrachtet werden. Um Überlappungen zu vermeiden, ist es nicht gestattet, diese drei Typen gemeinsam in einem Union-Typ zu verwenden. Ein solcher Versuch würde zu einem Fehler führen.

Weitere Neuerungen in PHP8.2 Disjunctive Normal Form (DNF) Typen in PHP

Eine der weiteren Neuerungen in PHP 8.2 ist die Disjunktive Normal Form, kurz DNF, stellt eine standardmäßige Methode dar, um boolesche Ausdrücke zu strukturieren. Sie setzt sich aus einer Kombination von Konjunktionen zusammen, was in der booleschen Logik einem ODER von UNDs entspricht.

Durch die Integration von DNF in Typendeklarationen in PHP wird eine normierte Methode bereitgestellt, um kombinierte Union- und Schnittmengen-Typen zu formulieren, die vom Parser interpretiert werden können. Die Einführung der DNF-Typenfunktionalität in PHP 8.2 bietet, wenn korrekt angewendet, eine einfache und dennoch leistungsstarke Lösung.

Ein Beispiel aus dem RFC, unter der Annahme vordefinierter Schnittstellen- und Klassendefinitionen, sieht wie folgt aus:

interface A {}
interface B {}
interface C extends A {}
interface D {}

class W implements A {}
class X implements B {}
class Y implements A, B {}
class Z extends Y implements C {}

Mit der Anwendung von DNF-Typen können Typdeklarationen wie nachstehend dargestellt definiert werden:

/ Akzeptiert ein Objekt, das sowohl A als auch B implementiert,
// ODER ein Objekt, das D implementiert
(A&B)|D

// Akzeptiert ein Objekt, das C implementiert, 
// ODER ein von X abgeleitetes Objekt, das auch D implementiert,
// ODER null
C|(X&D)|null

// Akzeptiert ein Objekt, das alle drei Schnittstellen A, B und D implementiert, 
// ODER einen int-Wert, 
// ODER null.
(A&B&D)|int|null

In bestimmten Situationen könnten die Typen nicht direkt in DNF-Form dargestellt werden. Ein Versuch, sie dennoch so zu deklarieren, würde zu einem Parse-Fehler führen. Sie können jedoch wie folgt umgeschrieben werden:

A&(B|D)
// Kann umgeschrieben werden als (A&B)|(A&D)

A|(B&(D|W)|null)
// Kann umgeschrieben werden als A|(B&D)|(B&W)|null

Es ist wichtig zu betonen, dass jedes Segment eines DNF-Typs einzigartig sein muss. Eine Deklaration wie (A&B)|(B&A) wäre beispielsweise nicht zulässig, da die beiden durch ODER verknüpften Segmente logisch identisch sind.

Zudem sind Segmente, die strikte Teilmengen eines anderen Segments sind, nicht erlaubt. Das liegt daran, dass die größere Menge bereits alle Instanzen der kleineren Menge umfasst, wodurch die Verwendung von DNF überflüssig wird.

Einführung der mysqli_execute_query Funktion und mysqli::execute_query Methode in PHP 8.2

Wer hat nicht schon einmal die mysqli_query() Funktion in Kombination mit potenziell unsicheren Benutzereingaben verwendet, um eine parametrisierte MySQLi-Abfrage durchzuführen? Mit den Neuerungen in PHP 8.2 wird dieser Vorgang deutlich sicherer und einfacher.

Die neueste PHP-Version führt die Funktion mysqli_execute_query($sql, $params) sowie die Methode mysqli::execute_query ein, um das Arbeiten mit parametrisierten MySQLi-Abfragen zu optimieren.

Grundlegend kombiniert diese Funktion die Vorteile von mysqli_prepare(), mysqli_execute() und mysqli_stmt_get_result(). Sie bereitet die MySQLi-Abfrage vor, bindet die Parameter (sofern vorhanden) und führt die Abfrage direkt innerhalb der Funktion aus. Bei erfolgreicher Durchführung liefert sie ein mysqli_result Objekt zurück. Im Falle eines Fehlers wird false zurückgegeben.

Ein praxisnahes Beispiel aus dem RFC verdeutlicht die Anwendung:

foreach ($db->execute_query('SELECT * FROM user WHERE name LIKE ? AND type_id IN (?, ?)', [$name, $type1, $type2]) as $row) {
    print_r($row);
}

Mit dieser Neuerung wird das Arbeiten mit MySQLi in PHP nicht nur sicherer, sondern auch effizienter und benutzerfreundlicher.

Zugriff auf enum-Eigenschaften innerhalb von const-Deklarationen

Ein aktueller RFC-Vorschlag ermöglicht es, mithilfe des -> bzw. ?-> Operators auf enum-Eigenschaften in const-Ausdrücken zuzugreifen.

Die Einführung dieser Funktion resultiert aus der Einschränkung, dass enum-Objekte an bestimmten Stellen, wie beispielsweise als Array-Schlüssel, nicht direkt verwendet werden können. In solchen Situationen ist es erforderlich, den spezifischen Wert des enum-Falls separat anzugeben.

Durch die Option, enum-Eigenschaften dort abzurufen, wo enum-Objekte nicht zulässig sind, wird dieser Prozess erheblich vereinfacht.

Dadurch wird der nachfolgende Code valide:

const C = [self::B->value => self::B];

Zusätzlich zur Hauptfunktion bietet der RFC auch eine Integration des Nullsafe-Operators ?->, um die Handhabung noch sicherer zu gestalten.

Konstanten in Traits

Traits in PHP dienen als Werkzeug zur Code-Wiederverwendung und sind besonders nützlich, um Code in verschiedenen Klassen zu teilen.

Bisher war es in Traits lediglich möglich, Methoden und Eigenschaften zu definieren, jedoch keine Konstanten. Das hat zur Folge, dass du keine konstanten Werte, die ein Trait voraussetzt, direkt innerhalb des Traits festlegen kannst. Um dieses Limit zu umgehen, war es notwendig, Konstanten entweder in der Klasse, die den Trait verwendet, oder in einer Schnittstelle, die von dieser Klasse implementiert wird, zu definieren.

Der vorgestellte RFC schlägt nun vor, die Deklaration von Konstanten innerhalb von Traits zu erlauben. Diese könnten dann ähnlich wie Klassen-Konstanten definiert werden. Ein Beispiel aus dem RFC zeigt die praktische Anwendung:

trait Foo {
    public const FLAG_1 = 1;
    protected const FLAG_2 = 2;
    private const FLAG_3 = 2;

    public function doFoo(int $flags): void {
        if ($flags & self::FLAG_1) {
            echo 'Flage 1 wurde aktiviert';
        }
        if ($flags & self::FLAG_2) {
            echo 'Flage 2 wurde aktiviert';
        }
        if ($flags & self::FLAG_3) {
            echo 'Flage 3 wurde aktiviert';
        }
    }
}

Die Konstanten eines Traits werden direkt in die Klasse integriert, die den Trait verwendet – genauso wie die Methoden und Eigenschaften des Traits. Dabei gelten für die Konstanten ähnliche Regeln wie für die Eigenschaften von Traits. Obwohl dieser RFC einen Schritt in die richtige Richtung darstellt, gibt es noch weiteren Bedarf zur Verfeinerung, um die Implementierung vollständig zu machen.

Veraltete Funktionen und Änderungen in PHP8.2

Änderungen bei dynamischen Eigenschaften und die Einführung von #[AllowDynamicProperties]

In PHP-Versionen bis einschließlich 8.1 war es möglich, Klasseneigenschaften, die nicht explizit deklariert wurden, dynamisch zu definieren und abzurufen. Ein Beispiel:

lass Artikel {
    private int $id;
}

$artikel = new Artikel();
$artikel->titel = 'Neuerungen in PHP8.2';

Obwohl die Klasse Artikel die Eigenschaft titel nicht definiert hat, erlaubt PHP das dynamische Hinzufügen von Eigenschaften. Dies kann zwar flexibel sein, birgt jedoch auch Risiken, insbesondere wenn unbeabsichtigt Eigenschaften hinzugefügt werden.

Dynamische Eigenschaften können zu unvorhersehbaren Fehlern führen. Ein Tippfehler bei der Definition einer Eigenschaft kann schwer zu erkennen sein, insbesondere wenn man innerhalb der Klasse nach Fehlern sucht.

Mit PHP 8.2 werden solche dynamischen Eigenschaften als veraltet betrachtet. Das Zuweisen von Werten zu nicht deklarierten Klasseneigenschaften löst nun eine deprecated aus.

class Example {}
$instance = new class Example;

// deprecated: Das Erstellen der dynamischen Eigenschaft Beispiel::$variable ist veraltet
$instance->variable = 1;

// Keine deprecated: Dynamische Eigenschaft existiert bereits.
$instance->variable = 2;

In PHP 9.0 wird das Hinzufügen solcher Eigenschaften einen ErrorException Fehler verursachen.

Für bestehenden Code, der dynamische Eigenschaften intensiv nutzt, bietet PHP 8.2 das Attribut #[AllowDynamicProperties] an. Damit können Klassen weiterhin dynamische Eigenschaften verwenden, ohne deprecated zu erhalten.

#[AllowDynamicProperties]
class Animal {}
class Docg extends Animal {}

// Keine <span style="background-color: rgba(0, 0, 0, 0.2); font-family: inherit; font-size: inherit; color: initial;">deprecated</span>
$instance1 = new Animale;
$instance1->beispiel = 1;

// Keine <span style="background-color: rgba(0, 0, 0, 0.2); font-family: inherit; font-size: inherit; color: initial;">deprecated</span> für abgeleitete Klassen
$instance2 = new Dog;
$instance2->beispiel = 1;

Gemäß dem RFC sind Klassen, die mit #[AllowDynamicProperties] markiert sind, und ihre abgeleiteten Klassen von der deprecated ausgenommen. Es ist wichtig zu wissen, dass in PHP 8.2 stdClass die Einzige integrierte Klasse ist, die mit diesem Attribut markiert ist. Zudem werden Eigenschaften, die über die Magic Methoden __get() oder __set() abgerufen werden, nicht als dynamisch betrachtet und lösen daher keine deprecated aus.

Entfernung von nur bedingt unterstützten Funktionsaufrufen (Callables)

In PHP 8.2 gibt es eine Neuerung, die zwar subtil, aber dennoch wichtig ist: Das Auslaufen von nur bedingt unterstützten Funktionsaufrufen, auch bekannt als Callables.

Solche Callables tragen den Namen „bedingt unterstützt“, da sie nicht direkt mittels $callable() aufgerufen werden können. Stattdessen müssen sie über die Funktion call_user_func($callable) angesprochen werden. Es gibt nur eine begrenzte Anzahl solcher Callables, darunter:

"self::methode"
"parent::methode"
"static::methode"
["self", "methode"]
["parent", "methode"]
["static", "methode"]
["Foo", "Bar::methode"]
[new Foo, "Bar::methode"]

Mit der Einführung von PHP 8.2 wird jeder Versuch, diese speziellen Callables zu nutzen – sei es durch Funktionen wie call_user_func() oder array_map() – eine Hinweisbenachrichtigung über deprecated ausgeben.

Der zugrundeliegende RFC bietet eine fundierte Erklärung für diese Entscheidung:

Wie im ursprünglichen RFC dargelegt, werden die Funktion is_callable() und der Datentyp callable diese speziellen Callables weiterhin als Ausnahmen anerkennen. Dies bleibt jedoch nur bis zur Version PHP 9.0 so, ab der die Unterstützung für sie gänzlich entfällt.

Um jegliche Missverständnisse zu vermeiden, wurde der Anwendungsbereich der Veraltungsbenachrichtigung durch einen zusätzlichen RFC erweitert. Dieser beinhaltet nun auch die genannten Ausnahmen.

Es ist erfreulich zu beobachten, wie PHP sich in Richtung eines eindeutig definierten callable Typs entwickelt.

Kennzeichnung als Deprecated für die Methoden #utf8_encode() und utf8_decode()

Die in PHP integrierten Methoden utf8_encode() und utf8_decode() dienen dazu, Zeichenketten, die im ISO-8859-1 („Latin 1“) Format kodiert sind, nach UTF-8 zu transformieren und umgekehrt.

Trotz ihrer Bezeichnung suggerieren sie eine breitere Anwendbarkeit, als sie tatsächlich bieten. Oftmals wird die „Latin 1“-Kodierung mit anderen Formaten, wie beispielsweise der „Windows Code Page 1252“, verwechselt.

Ein weiteres Problem ist das Auftreten von Mojibake, wenn diese Methoden nicht in der Lage sind, eine Zeichenkette korrekt zu konvertieren. Das Fehlen von Fehlerhinweisen erschwert zudem das Identifizieren solcher Probleme, insbesondere wenn sie in einem Kontext von sonst korrektem Text auftreten.

Mit PHP 8.2 werden die Methoden #utf8_encode() und utf8_decode() als veraltet markiert. Bei ihrer Verwendung werden folgende deprecated nachricht angezeigt:

Deprecated: Methode utf8_encode() ist veraltet Deprecated: Methode utf8_decode() ist veraltet Als Alternative schlägt der RFC vor, auf die in PHP verfügbaren Erweiterungen wie mbstring, iconv und intl zurückzugreifen.

Deprecated für ${} Syntax für String-Interpolation in PHP

In PHP gibt es verschiedene Ansätze, um Variablen in Strings mit doppelten Anführungszeichen („) und heredoc (<<<) zu integrieren:

• Direkte Integration von Variablen – “$foo”
• Nutzung von geschweiften Klammern außerhalb der Variablen – “{$foo}”
• Anwendung von geschweiften Klammern direkt nach dem Dollar-Symbol – “${foo}”
• Variable Ausdrücke – “${expr}” – äquivalent zu (string) ${expr}

Während die ersten beiden Ansätze ihre eigenen Stärken und Schwächen aufweisen, sind die letzten beiden in ihrer Syntax kompliziert und inkonsistent. Ab PHP 8.2 werden diese beiden speziellen Interpolationsmethoden als veraltet betrachtet.

Es wird empfohlen, in zukünftigen Projekten von der Verwendung dieser Interpolationsstile abzusehen:

„Grüße, ${welt}!„; Deprecated: Die Verwendung von ${} in Zeichenketten ist veraltet

„Grüße, ${(welt)}!„; Deprecated: Die Verwendung von ${} (variable Ausdrücke) in Zeichenketten ist veraltet

Mit der Einführung von PHP 9.0 werden diese veralteten Interpolationsmethoden nicht mehr unterstützt und lösen einen Ausnahme-Fehler aus.

Einstellung bestimmter mbstring-Methoden in PHP

PHPs mbstring-Funktionen (Multi-Byte-String) sind nützliche Werkzeuge, wenn es darum geht, mit Unicode, HTML-Entities und einigen traditionellen Textkodierungen zu arbeiten.

Doch Base64, Uuencode und QPrint gelten nicht als echte Textkodierungen. Trotzdem wurden sie aus historischen Gründen in diese Funktionen integriert. Es ist zu beachten, dass PHP auch dedizierte Funktionen für diese Kodierungen bereitstellt.

Für die Handhabung von HTML-Entities stellt PHP spezielle Funktionen wie htmlspecialchars() und htmlentities() zur Verfügung. Diese sind im Vergleich zu mbstring effizienter, da sie Zeichen wie <, > und & korrekt in HTML-Entities konvertieren.

PHP ist stets bemüht, seine Kernfunktionen zu optimieren, wie zum Beispiel die Verbesserungen in PHP 8.1 bei den HTML-Enkodierungs- und Dekodierungsfunktionen zeigen.

Daher wird ab PHP 8.2 davon abgeraten, mbstring für die folgenden Kodierungen zu verwenden (unabhängig von der Groß- und Kleinschreibung):

• BASE64
• UUENCODE
• HTML-ENTITIES
• html (ein Synonym für HTML-ENTITIES)
• Quoted-Printable
• qprint (ein Synonym für Quoted-Printable)

Beginnend mit PHP 8.2 wird ein Hinweis angezeigt, wenn mbstring zum Kodieren/Dekodieren der oben genannten Kodierungen verwendet wird. Ab PHP 9.0 wird die Unterstützung für diese Kodierungen in mbstring endgültig eingestellt.

Hier kleine Liste weiterer Neuerungen in PHP 8.2:

• Mit den Neuerungen in PHP 8.2 wurde die Funktion curl_upkeep zur Curl-Erweiterung hinzugefügt. Sie interagiert mit der Funktion curl_easy_upkeep() aus der zugrunde liegenden C-Bibliothek libcurl, auf die sich die PHP-Curl-Erweiterung stützt.
• Ein weiteres Highlight der Neuerungen in PHP 8.2 ist die Funktion ini_parse_quantity. Sie ermöglicht es, PHP INI-Direktiven mit einem Multiplikator-Suffix wie 25M für 25 Megabyte oder 42G für 42 Gigabyte zu interpretieren. Obwohl diese Suffixe in PHP-INI-Dateien häufig vorkommen, sind sie in anderen Kontexten weniger gebräuchlich. Die Funktion wandelt diese Werte in ihre entsprechende Byte-Größe um.
• Zudem wurde in PHP 8.2 die Funktion memory_reset_peak_usage eingeführt. Sie ermöglicht es, den von memory_get_peak_usage gemeldeten Höchstwert des Speicherverbrauchs zurückzusetzen, was insbesondere nützlich ist, wenn man den Speicherverbrauch mehrerer Durchläufe einer Aktion überwachen möchte.
• Eine weitere Neuerung in PHP 8.2 ist die Unterstützung des No-Capture-Modifikators (/n) in preg_* Funktionen. In regulären Ausdrücken markieren die Metazeichen () eine Fanggruppe. Mit dem /n-Modifikator kann dieses Verhalten jetzt unterdrückt werden.
• Schließlich wurde in den Neuerungen von PHP 8.2 festgelegt, dass die iterator_*() Familie nun alle Iterablen, einschließlich einfacher Arrays, akzeptieren muss, wodurch eine bisherige Einschränkung beseitigt wurde.

Zusammenfassung:

Die Neuerungen in PHP 8.2 bringt eine Reihe von Änderungen und Verbesserungen mit sich. Es gibt Optimierungen bei der Arbeit mit Typen und eine vereinfachte Abfrageausführung. Die Unterstützung für das Abrufen von Eigenschaften in Konstanten ausdrücken wurde erweitert, und es ist nun möglich, Konstanten in wiederverwendbaren Codeblöcken zu definieren. Gleichzeitig werden einige ältere Funktionen und Features als veraltet betrachtet und in zukünftigen Versionen entfernt. Insgesamt strebt PHP 8.2 danach, die Sprache moderner, effizienter und benutzerfreundlicher zu gestalten.

Es gibt noch weitere Neuerungen in PHP 8.2 die wert sind sich diese anzuschauen, allerdings würde das den Rahmen dieses Artikels sprengen. Man findet diese auf der offiziellen Site von PHP

Das alles in ganzen sind jede Menge interessanter und nützlicher Neuerungen in PHP 8.2.