PHP 7.4, das n\u00e4chste PHP 7 Minor Release, wurde am 28. November 2019 f\u00fcr die allgemeine Verf\u00fcgbarkeit freigegeben. Es ist also Zeit f\u00fcr uns, in einige der aufregendsten Erweiterungen und neuen Funktionen einzutauchen, die PHP schneller und zuverl\u00e4ssiger gemacht haben werden.<\/p>\n
Update:<\/strong> PHP 8.1 (offizielles Release)<\/a> ist jetzt f\u00fcr alle Kunden von Kinsta verf\u00fcgbar. PHP 7.4 wird von Kinsta nicht mehr unterst\u00fctzt. Bitte beachte, dass wir die PHP-Versionen 7.4, 8.0, 8.1, 8.2, 8.3, 8.4 und 8.5 unterst\u00fctzen.<\/p>\n Wenn PHP 7.4 die Leistung deutlich steigert und die Code-Lesbarkeit verbessert, wird PHP 8<\/a> der eigentliche Meilenstein f\u00fcr die PHP-Performance sein, da der Vorschlag zur JIT-Einbindung <\/a>bereits genehmigt wurde.<\/p>\n Wie auch immer, heute durchlaufen wir einige der interessantesten Features und \u00c4nderungen, die wir mit PHP 7.4 erwarten.\u00a0Nur f\u00fcr die Akten, das waren die wichtigen Daten f\u00fcr die Version 7.4:<\/p>\n Die vollst\u00e4ndige Liste der Features und Erg\u00e4nzungen findest du auf der offiziellen RFC-Seite<\/a>.<\/p>\n In diesem Beitrag behandeln wir einige \u00c4nderungen und Funktionen, die der Sprache mit der endg\u00fcltigen Version von PHP 7.4 hinzugef\u00fcgt werden sollten:<\/p>\n Seit PHP 5.6 verf\u00fcgbar, ist das Entpacken von Argumenten<\/a> eine Syntax zum Entpacken von Arrays und Traversables<\/a> in Argumentenlisten. Um ein Array oder ein Traversable zu entpacken, muss es mit … (3 Punkten) vorangestellt werden, wie im folgenden Beispiel gezeigt:<\/p>\n Nun schl\u00e4gt dieser PHP 7.4 RFC<\/a> vor, diese Funktion auf Array-Definitionen auszudehnen:<\/p>\n Der erste erkl\u00e4rte Vorteil des Spread Operators im Array-Ausdruck<\/strong> ist die Leistung. In der Tat, so hei\u00dft es in der RFC-Dokumentation<\/a>:<\/p>\n Spread-Operator sollte eine bessere Performance haben als Ein wesentlicher Vorteil des Spread-Operators ist, dass er alle durchquerbaren Objekte unterst\u00fctzt, w\u00e4hrend die Funktion Hier ist ein Beispiel f\u00fcr das Entpacken von Argumenten im Array-Ausdruck:<\/p>\n Wenn du diesen Code mit in PHP 7.3 oder fr\u00fcher ausf\u00fchrst, l\u00f6st PHP einen Parse-Fehler aus:<\/p>\n Stattdessen w\u00fcrde PHP 7.4 ein Array zur\u00fcckgeben:<\/p>\n Der RFC besagt, dass wir das gleiche Array mehrfach erweitern k\u00f6nnen. Au\u00dferdem k\u00f6nnen wir die Syntax des Spread Operators \u00fcberall im Array verwenden, da normale Elemente vor oder nach dem Spread Operator hinzugef\u00fcgt werden k\u00f6nnen. Der folgende Code wird also so funktionieren, wie wir es erwarten k\u00f6nnen:<\/p>\n Es ist auch m\u00f6glich, Arrays, die von einer Funktion zur\u00fcckgegeben werden, direkt in ein neues Array zu entpacken:<\/p>\n PHP 7.4 gibt das folgende Array aus:<\/p>\n Wir k\u00f6nnen auch die Generatorsyntax<\/a> verwenden:<\/p>\n Es ist uns jedoch nicht gestattet, Arrays zu entpacken, die als Referenz \u00fcbergeben werden. Betrachte das folgende Beispiel:<\/p>\n Wenn wir versuchen w\u00fcrden, ein Array per Referenz zu entpacken, l\u00f6st PHP den folgenden Parse-Fehler aus:<\/p>\n Jedenfalls, wenn die Elemente des ersten Arrays durch Referenz gespeichert werden, werden sie auch durch Referenz im zweiten Array gespeichert. Hier ist ein Beispiel:<\/p>\n Und hier ist, was wir mit PHP 7.4 erreichen:<\/p>\n Der Vorschlag des Spread-Betreibers wurde mit 43 zu 1 Stimmen angenommen.<\/p>\n In PHP gelten anonyme Funktionen<\/a> als recht ausf\u00fchrlich und schwer zu implementieren und zu warten. Dieser RFC<\/a> schl\u00e4gt die Einf\u00fchrung der k\u00fcrzeren und klareren Syntax der Arrow Functions<\/strong> (oder Short Closures) vor, die es uns erm\u00f6glichen sollte, unseren PHP-Code deutlich zu bereinigen.<\/p>\n Betrachte das folgende Beispiel:<\/p>\n PHP 7.4 erlaubt es, eine pr\u00e4zisere Syntax zu verwenden, und die obige Funktion k\u00f6nnte wie folgt umgeschrieben werden:<\/p>\n Derzeit k\u00f6nnen anonyme Funktionen<\/a> (Closures) Variablen, die im \u00fcbergeordneten Bereich definiert sind, dank des Aber mit PHP 7.4 werden Variablen, die im \u00fcbergeordneten Bereich definiert sind, implizit durch Wert erfasst<\/strong> (implizite Bindung nach Wert). So k\u00f6nnen wir die gesamte oben beschriebene Funktion in eine einzige Zeile schreiben:<\/p>\n Die im \u00fcbergeordneten Bereich definierte Variable kann in der Pfeilfunktion genauso verwendet werden, als ob wir Die neue Syntax ist eine gro\u00dfe Verbesserung der Sprache, da sie es uns erm\u00f6glicht, besser lesbaren und wartbaren Code zu erstellen. Wir k\u00f6nnen auch Parameter- und R\u00fcckgabetypen<\/a>, Standardwerte, Argumentlisten mit variabler L\u00e4nge (variadische Funktionen<\/a>) verwenden, wir k\u00f6nnen \u00fcbergeben und per Referenz zur\u00fcckkehren, etc. Schlie\u00dflich k\u00f6nnen Short Closures auch in Klassenmethoden verwendet werden, und sie k\u00f6nnen die Variable Dieser RFC wurde mit 51 bis 8 Stimmen genehmigt, so dass wir davon ausgehen k\u00f6nnen, dass er Teil der PHP 7.4 Erg\u00e4nzungen sein wird.<\/p>\n In PHP 7 hinzugef\u00fcgt, ist der Koaleszenzoperator<\/a>\u00a0( Was dieser Code tut, ist ziemlich einfach: Er holt den Anforderungsparameter und setzt einen Standardwert, wenn er nicht existiert.<\/strong> Die Bedeutung dieser Zeile ist klar, aber was w\u00e4re, wenn wir viel l\u00e4ngere Variablennamen wie in diesem Beispiel aus dem RFC h\u00e4tten?<\/p>\n Auf lange Sicht k\u00f6nnte dieser Code etwas schwierig zu pflegen sein. Um Entwicklern zu helfen, intuitiveren Code zu schreiben, schl\u00e4gt dieser RFC<\/a> die Einf\u00fchrung des null coalescing assignment operator<\/strong> ( Wenn der Wert des linken Parameters Dieser Vorschlag wurde mit 37 zu 4 Stimmen angenommen.<\/p>\n Argumenttypdeklarationen oder Typhinweise erm\u00f6glichen es, den Typ einer Variablen anzugeben, der voraussichtlich an eine Funktion oder eine Klassenmethode \u00fcbergeben wird. Typ-Hinweise sind eine Funktion, die seit PHP 5 verf\u00fcgbar ist, und seit PHP 7.2<\/a> k\u00f6nnen wir sie mit dem Es werden alle Typen unterst\u00fctzt, mit Ausnahme von Der RFC erkl\u00e4rt den Grund, warum Der Void Typ wird nicht unterst\u00fctzt, da er nicht n\u00fctzlich ist und eine unklare Semantik hat.<\/p><\/blockquote>\n Der Callable Type wird nicht unterst\u00fctzt, da sein Verhalten kontextabh\u00e4ngig ist.<\/p><\/blockquote>\n Also k\u00f6nnen wir Typen k\u00f6nnen f\u00fcr statische Eigenschaften verwendet werden:<\/p>\n Sie sind auch mit der Es ist m\u00f6glich, Standardeigenschaftenwerte festzulegen, die nat\u00fcrlich mit dem deklarierten Eigenschaftentyp \u00fcbereinstimmen m\u00fcssen, aber nur nullbare Eigenschaften k\u00f6nnen einen Standard- Der gleiche Typ gilt f\u00fcr alle Eigenschaften in einer einzigen Deklaration:<\/p>\n Was passiert, wenn wir einen Fehler machen? Beachte den folgenden Code:<\/p>\n Im obigen Code haben wir einen Zeichenketten-Eigenschaftstyp deklariert, aber wir haben ein Array als Eigenschaftswert gesetzt. In einem solchen Szenario erhalten wir den folgenden Fatalen Fehler:<\/p>\n Dieser RFC wurde mit 70 zu 1 Stimmen genehmigt.<\/p>\n Mit diesem RFC<\/a> f\u00fchrt PHP 7.4 die Klasse WeakReference<\/a> ein, die es Programmierern erm\u00f6glicht, eine Referenz auf ein Objekt zu behalten, das nicht verhindert, dass das Objekt selbst zerst\u00f6rt wird.<\/p>\n Derzeit unterst\u00fctzt PHP Schwache Referenzen, indem es eine Erweiterung wie pecl-weakref verwendet. Wie auch immer, die neue API unterscheidet sich von der dokumentierten Hier ist ein Beispiel vom Autor<\/a> dieses Vorschlags, Nikita Popov:<\/p>\n Der erste Slides for my PHP 7.4 talk at #PHPRussia2019<\/a>. Was a great conference!https:\/\/t.co\/zLr9Bj2aKl<\/a><\/p>\n — Nikita Popov (@nikita_ppv) May 19, 2019<\/a><\/p><\/blockquote>\n\n
Was ist neu in PHP mit PHP 7.4?<\/h2>\n
Vergesse array_merge: PHP 7.4 bringt den Spread-Operator in Array-Ausdruck<\/h3>\n
function test(...$args) { var_dump($args); }\ntest(1, 2, 3);<\/code><\/pre>\n$arr = [...$args];<\/code><\/pre>\narray_merge<\/code>. Das liegt nicht nur daran, dass der Spread-Operator eine Sprachstruktur ist, w\u00e4hrend array_merge<\/code> eine Funktion ist, sondern auch daran, dass die Kompilierzeitoptimierung f\u00fcr konstante Arrays performant sein kann.<\/p><\/blockquote>\narray_merge<\/code> nur Arrays unterst\u00fctzt.<\/p>\n$parts = ['apple', 'pear'];\n$fruits = ['banana', 'orange', ...$parts, 'watermelon'];\nvar_dump($fruits);<\/code><\/pre>\nParse error: syntax error, unexpected '...' (T_ELLIPSIS), expecting ']' in \/app\/spread-operator.php on line 3<\/code><\/pre>\narray(5) {\n\t[0]=>\n\tstring(6) \"banana\"\n\t[1]=>\n\tstring(6) \"orange\"\n\t[2]=>\n\tstring(5) \"apple\"\n\t[3]=>\n\tstring(4) \"pear\"\n\t[4]=>\n\tstring(10) \"watermelon\"\n}<\/code><\/pre>\n$arr1 = [1, 2, 3];\n$arr2 = [4, 5, 6];\n$arr3 = [...$arr1, ...$arr2];\n$arr4 = [...$arr1, ...$arr3, 7, 8, 9];<\/code><\/pre>\nfunction buildArray(){\n\treturn ['red', 'green', 'blue'];\n}\n$arr1 = [...buildArray(), 'pink', 'violet', 'yellow'];<\/code><\/pre>\narray(6) {\n\t[0]=>\n\tstring(3) \"red\"\n\t[1]=>\n\tstring(5) \"green\"\n\t[2]=>\n\tstring(4) \"blue\"\n\t[3]=>\n\tstring(4) \"pink\"\n\t[4]=>\n\tstring(6) \"violet\"\n\t[5]=>\n\tstring(6) \"yellow\"\n}<\/code><\/pre>\nfunction generator() {\n\tfor ($i = 3; $i <= 5; $i++) {\n\t\tyield $i;\n\t}\n}\n$arr1 = [0, 1, 2, ...generator()];<\/code><\/pre>\n$arr1 = ['red', 'green', 'blue'];\n$arr2 = [...&$arr1];<\/code><\/pre>\nParse error: syntax error, unexpected '&' in \/app\/spread-operator.php on line 3<\/code><\/pre>\n$arr0 = 'red';\n$arr1 = [&$arr0, 'green', 'blue'];\n$arr2 = ['white', ...$arr1, 'black'];<\/code><\/pre>\narray(5) {\n\t[0]=>\n\tstring(5) \"white\"\n\t[1]=>\n\t&string(3) \"red\"<\/strong>\n\t[2]=>\n\tstring(5) \"green\"\n\t[3]=>\n\tstring(4) \"blue\"\n\t[4]=>\n\tstring(5) \"black\"\n}<\/code><\/pre>\nArrow Functions 2.0 (Short Closures)<\/h3>\n
function cube($n){\n\treturn ($n * $n * $n);\n}\n$a = [1, 2, 3, 4, 5];\n$b = array_map('cube', $a);\nprint_r($b);<\/code><\/pre>\n$a = [1, 2, 3, 4, 5];\n$b = array_map(fn($n) => $n * $n * $n, $a);\nprint_r($b);<\/code><\/pre>\nuse<\/code> Language Konstrukts erben, wie unten gezeigt:<\/p>\n$factor = 10;\n$calc = function($num) use($factor){\n\treturn $num * $factor;\n};<\/code><\/pre>\n$factor = 10;\n$calc = fn($num) => $num * $factor;<\/code><\/pre>\n($var)<\/code> verwenden w\u00fcrden, und es ist nicht m\u00f6glich, eine Variable aus dem \u00fcbergeordneten Bereich zu \u00e4ndern.<\/p>\n$this<\/code> wie normale Closures verwenden.<\/p>\nNull Coalescing Assignment Operator<\/h3>\n
??<\/code>) praktisch, wenn wir einen tern\u00e4ren Operator in Verbindung mit isset()<\/code> verwenden m\u00fcssen. Es gibt den ersten Operanden zur\u00fcck, wenn er existiert und ist nicht NULL<\/code>. Andernfalls gibt es den zweiten Operanden zur\u00fcck. Hier ist ein Beispiel:<\/p>\n$username = $_GET['user'] ?? 'nobody';<\/code><\/pre>\n$this->request->data['comments']['user_id'] = $this->request->data['comments']['user_id'] ?? 'value';<\/code><\/pre>\n??=<\/code>) vor. Anstatt also den vorherigen Code zu schreiben, k\u00f6nnten wir folgendes schreiben:<\/p>\n$this->request->data['comments']['user_id'] ??= 'value';<\/code><\/pre>\nnull<\/code> ist, dann wird der Wert des rechten Parameters verwendet.\u00a0Beachte, dass der Koaleszenzoperator zwar ein Vergleichsoperator ist, aber ??=<\/code> ein Zuordnungsoperator ist.<\/p>\nTypisierte Eigenschaften 2.0<\/h3>\n
object<\/code>-datentyp verwenden. Jetzt bringt PHP 7.4 Type Hinting einen Schritt voran, indem es die Unterst\u00fctzung f\u00fcr erstklassige Property Type Declarations<\/a> hinzuf\u00fcgt. Hier ist ein sehr einfaches Beispiel:<\/p>\nclass User {\n\tpublic int $id;\n\tpublic string $name;\n}<\/code><\/pre>\nvoid<\/code> und callable<\/code>:<\/p>\npublic int $scalarType;\nprotected ClassName $classType;\nprivate ?ClassName $nullableClassType;<\/code><\/pre>\nvoid<\/code> und callable<\/code> nicht unterst\u00fctzt werden:<\/p>\nbool<\/code>, int<\/code>, float<\/code>, string<\/code>, array<\/code>, object<\/code>, iterable<\/code>, self<\/code>, parent<\/code>, jeden Klassen- oder Interface-Namen und nullable<\/a> Typen<\/a> (?type<\/code>) verwenden.<\/p>\npublic static iterable $staticProp;<\/code><\/pre>\nvar<\/code>-Notation erlaubt:<\/p>\nvar bool $flag;<\/code><\/pre>\nnull<\/code>-wert haben:<\/p>\npublic string $str = \"foo\";\npublic ?string $nullableStr = null;<\/code><\/pre>\npublic float $x, $y;<\/code><\/pre>\nclass User {\n\tpublic int $id;\n\tpublic string $name;\n}\n\n$user = new User;\n$user->id = 10;\n$user->name = [];<\/code><\/pre>\nFatal error: Uncaught TypeError: Typed property User::$name must be string, array used in \/app\/types.php:9<\/code><\/pre>\nWeak References<\/h3>\n
WeakRef<\/code>-Klasse.<\/p>\n$object = new stdClass;\n$weakRef = WeakReference::create($object);\n\nvar_dump($weakRef->get());\nunset($object);\nvar_dump($weakRef->get());<\/code><\/pre>\nvar_dump<\/code> druckt das object(stdClass)#1 (0) {}<\/code>, w\u00e4hrend der zweite var_dump<\/code> NULL<\/code> druckt, da das referenzierte Objekt zerst\u00f6rt wurde.<\/p>\n\n