{"id":67410,"date":"2023-11-29T08:24:40","date_gmt":"2023-11-29T07:24:40","guid":{"rendered":"https:\/\/kinsta.com\/de\/?p=67410&preview=true&preview_id=67410"},"modified":"2023-12-01T11:15:25","modified_gmt":"2023-12-01T10:15:25","slug":"php-8-3","status":"publish","type":"post","link":"https:\/\/kinsta.com\/de\/blog\/php-8-3\/","title":{"rendered":"PHP 8.3: Was ist neu und was hat sich in der neuesten Version ge\u00e4ndert?"},"content":{"rendered":"

PHP 8.3 wurde p\u00fcnktlich am 23. November ver\u00f6ffentlicht und enth\u00e4lt viele neue Funktionen und Verbesserungen seit der Einf\u00fchrung von PHP 8.2<\/a>. Auch wenn es sich offiziell um eine kleinere Version handelt, k\u00f6nnten sich einige der \u00c4nderungen in 8.3 direkt auf deine Arbeit mit PHP auswirken – und dir vielleicht helfen, schneller und mit weniger Fehlern zu programmieren.<\/p>\n

Werfen wir einen Blick auf die gro\u00dfen – und manchmal auch nicht so gro\u00dfen – \u00c4nderungen, die mit dieser neuen Version einhergehen.<\/p>\n

<\/div><\/kinsta-auto-toc>\n

Neue Funktionen und Verbesserungen in PHP 8.3<\/h2>\n

Beginnen wir mit den Funktionen von PHP 8.3, die die meisten Schlagzeilen machen.<\/p>\n

<\/div><\/kinsta-auto-toc>\n

Typisierte Klassenkonstanten<\/h3>\n

Die M\u00f6glichkeit, Typen f\u00fcr Klasseneigenschaften zu deklarieren, steht uns seit PHP 7.4<\/a> zur Verf\u00fcgung. Doch trotz zahlreicher Verbesserungen der PHP-Typisierung im Laufe der Jahre wurde sie nicht auf Konstanten ausgeweitet – bis jetzt.<\/p>\n

Klassenkonstanten – und dazu geh\u00f6ren auch Interface-, Trait- und Enum-Konstanten – k\u00f6nnen in PHP 8.3 typisiert werden, so dass es unwahrscheinlicher wird, dass Entwickler\/innen von der Absicht abweichen, die hinter der urspr\u00fcnglichen Deklaration einer Konstante steht.<\/p>\n

Hier ist ein einfaches Beispiel mit einer Schnittstelle:<\/p>\n

\/\/ Legal:\ninterface ConstTest {\n    \/\/ Declared type and value are both strings\n    const string VERSION = \"PHP 8.3\";\n}\n\n\/\/ Illegal:\ninterface ConstTest {\n    \/\/ Type and value mismatch in this initial declaration\n    const float VERSION = \"PHP 8.3\";\n}<\/code><\/pre>\n
Der wahre Wert dieser typisierten Klassenkonstanten<\/a> zeigt sich bei der Arbeit in Klassen, die von den Basisdeklarationen abgeleitet sind. W\u00e4hrend eine Childclass einer Konstante h\u00e4ufig einen neuen Wert zuweisen kann, kann PHP 8.3 verhindern, dass der Typ der Konstante versehentlich ge\u00e4ndert wird, so dass sie nicht mehr mit der urspr\u00fcnglichen Deklaration kompatibel ist:<\/p>\n
class ConstTest {\n    const string VERSION = \"PHP 8.2\";\n}\n\nclass MyConstTest extends ConstTest {\n\n    \/\/ Legal:\n    \/\/ It's OK to change the value of VERSION here\n    const string VERSION = \"PHP 8.3\";\n\n    \/\/ Illegal:\n    \/\/ Type must be declared if it was specified in the base class\n    const VERSION = \"PHP 8.3\";\n\n    \/\/ Illegal:\n    \/\/ In this case, we can't change the type declared in the \n    \/\/ base class, even if the new type and its value are compatible.\n    const float VERSION = 8.3;\n}<\/code><\/pre>\n
Denke daran, dass der Typ, der einer Klassenkonstante zugewiesen wird, variieren kann, wenn mehrere Typen „eingegrenzt“ oder ein ansonsten kompatibler Typ verwendet wird:<\/p>\n
class ConstTest {\n    const string|float VERSION = \"PHP 8.2\";\n}\n\nclass MyConstTest extends ConstTest {\n\n    \/\/ Legal:\n    \/\/ Here, it's OK to narrow the type declaration to string or float\n    const string VERSION = \"PHP 8.3\";\n    const float VERSION = 8.3;\n\n    \/\/ Legal:\n    \/\/ Value could be an int, but it's compatible with float \n    const float VERSION = 8;\n\n    \/\/ Illegal:\n    \/\/ We can't widen the type options here to include int\n    const string|float|int VERSION = 8;\n}<\/code><\/pre>\n
Zwei Typen, die f\u00fcr andere Eigenschaften bei der Validierung von R\u00fcckgabewerten unterst\u00fctzt werden – void<\/code> und never<\/code> – werden nicht als Klassenkonstanten-Typen unterst\u00fctzt.<\/p>\n
Eine neue json_validate()<\/code> Funktion<\/h3>\n
Wenn du mit JSON-kodierten Daten arbeitest, ist es gut zu wissen, ob die Nutzdaten syntaktisch g\u00fcltig sind, bevor du versuchst, etwas mit ihnen zu machen.<\/p>\n
In fr\u00fcheren PHP-Versionen haben Entwickler die Funktion json_decode()<\/code> verwendet und auf Fehler gepr\u00fcft, w\u00e4hrend diese Funktion versucht hat, JSON-Daten in assoziative Arrays oder Objekte zu verwandeln. Die neue Funktion von PHP 8.3 json_validate()<\/a><\/code> Funktion f\u00fchrt die Fehlerpr\u00fcfung durch, ohne den gesamten Speicher zu verbrauchen, der zum Aufbau dieser Array- oder Objektstrukturen erforderlich ist.<\/p>\n
In der Vergangenheit h\u00e4ttest du also eine JSON-Nutzlast etwa so validieren k\u00f6nnen:<\/p>\n
$obj = json_decode($maybeJSON);\n\nif (json_last_error() === JSON_ERROR_NONE) {\n    \/\/ Probably do something with $obj   \n}<\/code><\/pre>\n
Wenn du im obigen Beispiel nicht sofort etwas mit $obj<\/code> machen willst, werden eine Menge Ressourcen verbraucht, nur um die G\u00fcltigkeit der urspr\u00fcnglichen JSON-Nutzdaten zu best\u00e4tigen. In PHP 8.3 kannst du so etwas tun und etwas Speicher sparen:<\/p>\n
if (json_validate($maybeJSON)) {\n    \/\/ Do something with $maybeJSON   \n}<\/code><\/pre>\n
Hinweis:<\/strong> Es macht nicht viel Sinn, json_validate()<\/code> zu verwenden und die Daten dann sofort durch json_decode()<\/code> laufen zu lassen, wobei die Speicherressourcen von decode sowieso verbraucht werden. Es ist wahrscheinlicher, dass du die neue Funktion verwendest, um das JSON zu validieren, bevor du es irgendwo speicherst oder als Antwort auf eine Anfrage \u00fcbermittelst.<\/p>\n
Deep Cloning von readonly<\/code> Eigenschaften<\/h3>\n
Die M\u00f6glichkeit, einzelne Klasseneigenschaften als readonly<\/code> zu deklarieren, wurde in PHP 8.1<\/a> eingef\u00fchrt. Mit PHP 8.2 wurde die M\u00f6glichkeit eingef\u00fchrt, dieses Attribut einer ganzen Klasse<\/a> zuzuweisen. Viele Entwickler waren jedoch der Meinung, dass die Einschr\u00e4nkungen bei der Arbeit mit Klassen, die solche Eigenschaften enthalten, einer sinnvollen Programmierung im Wege stehen.<\/p>\n
In einem RFC zur \u00c4nderung des Verhaltens von readonly<\/code><\/a> wurden zwei Vorschl\u00e4ge gemacht:<\/p>\n
    \n
  1. Erlaube Klassen, die nicht readonly<\/code> sind, Klassen zu erweitern<\/li>\n
  2. Erlaube, dass die Eigenschaften von readonly<\/code> beim Klonen reinitialisiert werden<\/li>\n<\/ol>\n
    Der zweite Vorschlag hat es in PHP 8.3 geschafft. Der neue Ansatz erlaubt es, Instanzen einer Klasse mit readonly<\/code> Eigenschaften innerhalb der __clone<\/code> magic Methode zu reinitialisieren (auch \u00fcber Funktionen, die von __clone<\/code> aus aufgerufen werden).<\/p>\n
    Dieses Codebeispiel aus dem RFC zeigt, wie es funktioniert:<\/p>\n
    class Foo {\n    public function __construct(\n        public readonly DateTime $bar,\n        public readonly DateTime $baz\n    ) {}\n \n    public function __clone() {\n        \/\/ $bar will get a new DateTime when clone is invoked\n        $this->bar = clone $this->bar; \n\n        \/\/ And this function will be called\n        $this->cloneBaz();\n    }\n \n    private function cloneBaz() {\n       \/\/ This is legal when called from within __clone\n        unset($this->baz); \n    }\n}\n \n$foo = new Foo(new DateTime(), new DateTime());\n$foo2 = clone $foo;<\/code><\/pre>\n
    Neues #[\\Override]<\/code> Attribut<\/h3>\n
    Bei der Implementierung von Schnittstellen in PHP stellen Programmierer detaillierte Funktionen f\u00fcr die in diesen Schnittstellen genannten Methoden bereit. Bei der Erstellung einer Instanz einer Klasse k\u00f6nnen Programmierer eine \u00fcbergeordnete Methode au\u00dfer Kraft setzen, indem sie eine alternative Version mit demselben Namen und einer kompatiblen Signatur in der Child-Klasse erstellen.<\/p>\n
    Ein Problem besteht darin, dass Programmierer denken<\/em> k\u00f6nnten, dass<\/em> sie eine Schnittstellenmethode implementieren oder eine \u00fcbergeordnete Methode au\u00dfer Kraft setzen, obwohl sie es nicht tun. Es kann sein, dass sie eine v\u00f6llig neue Methode erstellen, weil sie sich im Namen der Child-Methode vertippt haben oder weil die Methoden im Code der Parent-Klasse entfernt oder umbenannt wurden.<\/p>\n
    PHP 8.3 f\u00fchrt das Attribut #[\\Override]<\/code> ein, um Programmierern zu helfen, deutlich zu machen, dass eine Methode eine gewisse Abstammung innerhalb des Codes haben muss.<\/p>\n
    Hier ist ein einfaches Beispiel:<\/p>\n
    class A {\n    protected function ovrTest(): void {}\n}\n\n\/\/ This will work because ovrTest() \n\/\/ can be found in the parent class\nclass B extends A {\n    #[\\Override]\n    public function ovrTest(): void {}\n}\n\n\/\/ This will fail because ovrBest() \n\/\/ (probably a typo) is not in the parent\nclass C extends A {\n    #[\\Override]\n    public function ovrBest(): void {}\n}<\/code><\/pre>\n
    Dynamische Abfrage von Klassenkonstanten und Enum-Mitgliedern<\/h3>\n
    Anders als bei anderen Eigenschaften im PHP-Code war das Abrufen von Klassenkonstanten und Enum-Mitgliedern mit Variablennamen bisher etwas umst\u00e4ndlich. Vor PHP 8.3 konntest du das mit der Funktion constant()<\/code> wie folgt machen:<\/p>\n
    class MyClass {\n    public const THE_CONST = 9;\n}\n\nenum MyEnum int {\n    case FirstMember = 9;\n    case SecondMember = 9;\n}\n\n$constantName = 'THE_CONST';\n$memberName = 'FirstMember';\n\necho constant('MyClass::' . $constantName);\necho constant('MyEnum::' . $memberName)->value;<\/code><\/pre>\n
    Mit denselben Klassen- und Enum-Definitionen wie oben kannst du jetzt das gleiche Ergebnis mit dem dynamischen Abrufen von Konstanten<\/a> in PHP 8.3 erreichen:<\/p>\n
    $constantName = 'THE_CONST';\n$memberName = 'FirstMember';\n\necho MyClass::{$constantName};\necho MyEnum::{$memberName}->value;<\/code><\/pre>\n
    Neue getBytesFromString()<\/code> Methode<\/h3>\n
    Wolltest du schon einmal zuf\u00e4llige Zeichenketten aus einer vorher festgelegten Sammlung von Zeichen erzeugen? Das kannst du jetzt ganz einfach mit der getBytesFromString()<\/a><\/code> Methode, die der Erweiterung Random in PHP 8.3 hinzugef\u00fcgt wurde.<\/p>\n
    Diese neue Methode ist einfach: Du \u00fcbergibst ihr eine Zeichenkette als Ausgangsmaterial und gibst an, wie viele davon du verwenden m\u00f6chtest. Die Methode w\u00e4hlt dann nach dem Zufallsprinzip Bytes aus der Zeichenkette aus, bis sie die angegebene L\u00e4nge erreicht.<\/p>\n
    Hier ist ein einfaches Beispiel:<\/p>\n
    $rando = new Random\\Randomizer();\n$alpha = 'ABCDEFGHJKMNPQRSTVWXYZ';\n\n$rando->getBytesFromString($alpha, 6); \/\/  \"MBXGWL\"\n$rando->getBytesFromString($alpha, 6); \/\/  \"LESPMG\"\n$rando->getBytesFromString($alpha, 6); \/\/  \"NVHWXC\"<\/code><\/pre>\n
    Es ist m\u00f6glich, dass die angeforderte L\u00e4nge der zuf\u00e4lligen Ausgabe mehr Bytes hat als der Eingangsstring:<\/p>\n
    $rando = new Random\\Randomizer();\n$nums = '123456';\n\n$rando->getBytesFromString($nums, 10); \/\/  \"2526341615\"<\/code><\/pre>\n
    Bei einer Eingabekette mit eindeutigen Zeichen hat jedes Zeichen die gleiche Chance, f\u00fcr das Zufallsergebnis ausgew\u00e4hlt zu werden. Allerdings k\u00f6nnen Zeichen gewichtet werden, indem sie h\u00e4ufiger als andere in der Eingabe vorkommen. Ein Beispiel:<\/p>\n
    $rando = new Random\\Randomizer();\n$weighted = 'AAAAA12345';\n\n$rando->getBytesFromString($weighted, 5); \/\/  \"1AA53\"\n$rando->getBytesFromString($weighted, 10); \/\/  \"42A5A1AA3A\"<\/code><\/pre>\n
    Neue Methoden getFloat()<\/code> und nextFloat()<\/code><\/h3>\n
    Als Erweiterung der Random-Erweiterung f\u00fchrt PHP 8.3 zwei neue Methoden zur Erzeugung zuf\u00e4lliger Float-Werte ein: getFloat()<\/code> und nextFloat()<\/code>.<\/p>\n
    Hier ist ein Beispiel:<\/p>\n
    $rando = new Random\\Randomizer();\n\n\/\/ Generate a float value between a minimum \n\/\/  value of 0 and a maximum value of 5\n$rando->getFloat(0,5); \/\/ 2.3937446906217<\/code><\/pre>\n
    Die Methode getFloat()<\/code> akzeptiert neben dem Minimal- und Maximalwert auch einen dritten Parameter. Mit einer Random\\IntervalBoundary<\/strong> Enum kann man festlegen, ob die Min- und Max-Werte selbst von der Funktion zur\u00fcckgegeben werden k\u00f6nnen.<\/p>\n
    Hier sind die Regeln:<\/p>\n