PHP 7.4 geeft een enorme boost in performance en leesbaarheid van code en wordt beschouwd als een tussenstap naar PHP 8<\/a>. Voor deze laatste versie zijn de verwachtingen hooggespannen, helemaal wat betreft performance, omdat de opname van JIT<\/a> al is goedgekeurd.<\/p>\n Hoe dan ook, vandaag bespreken we meest interessante functies en veranderingen die we kunnen verwachten van PHP 7.4. Dit waren de belangrijkste datums voor versie 7.4:<\/p>\n De volledige lijst met features en toevoegingen kan je vinden op de offici\u00eble RFC-pagina<\/a> vinden.<\/p>\n In dit artikel bespreken we een aantal veranderingen en features die aan de taal worden toegevoegd wanneer de definitieve versie van PHP 7.4 wordt uitgebracht:<\/p>\n Argument unpacking<\/a> is een syntax die sinds PHP 5.6 gebruikt kan worden om arrays en Traversables <\/a>\u00a0uit te pakken in argumentlijsten. Om een array of een Traversable uit te pakken, moet deze worden voorafgegaan door … (3 punten), zoals je in het onderstaande voorbeeld kan zien:<\/p>\n In PHP 7.4 RFC<\/a> staat het voorstel om deze feature uit te breiden naar array definitions<\/p>\n Het eerste voordeel van het gebruik van Spread Operator in array expression<\/strong> heeft te maken met de performance. Dit is wat het RFC-document vermeldt<\/a>:<\/p>\n Spread operator zou voor betere prestaties zorgen dan Een belangrijk voordeel van Spread operator is dat deze alle verplaatsbare objecten ondersteunt, terwijl de Hier is een voorbeeld van argument unpacking in array expression:<\/p>\n Als je deze code uitvoert met PHP 7.3 of lager, dan krijg je een PHP Parse-error:<\/p>\n In PHP 7.4 krijg je echter een array terug:<\/p>\n De RFC meldt verder dat we deze array ook meerdere keren kunnen uitbreiden. We kunnen de Spread Operator-syntax overal binnen de array gebruiken, omdat normale elementen v\u00f3\u00f3r of na de spread operator kunnen worden toegevoegd. Dus de volgende code werkt zoals we kunnen verwachten:<\/p>\n Het is ook mogelijk om een array, die door een functie is geretourneerd, direct uit te pakken in een nieuwe array:<\/p>\n In PHP 7.4 krijg je dan de volgende array:<\/p>\n We kunnen ook de generator syntax<\/a> gebruiken:<\/p>\n Echter, het is niet toegestaan om arrays uit de pakken die zijn doorgegeven door een verwijzing. In het volgende voorbeeld leg ik het uit:<\/p>\n Als we nu een array willen uitpakken door te verwijzen, dan genereert PHP de volgende Parse-error:<\/p>\n Als de elementen van de eerste array door verwijzing zijn opgeslagen, worden ze ook door verwijzing in de tweede array opgeslagen. Hier is een voorbeeld:<\/p>\n Dit is wat we krijgen met PHP 7.4:<\/p>\n Het voorstel om Spread operator toe te voegen was goedgekeurd met 43 stemmen voor en 1 stem tegen.<\/p>\n In PHP worden anonieme functies<\/a> vaak beschouwd als moeilijk te begrijpen en lastig in te voeren en te onderhouden. Deze RFC<\/a> stelt voor om de kortere syntax van de arrow functies<\/strong> (of short closures) te introduceren. Hiermee zou je je PHP-code flink kunnen opschonen.<\/p>\n In het volgende voorbeeld leg ik het uit:<\/p>\n PHP 7.4 maakt het gebruik van een meer beknopte syntax mogelijk en de bovenstaande functie kan als volgt worden herschreven:<\/p>\n Momenteel kunnen anonieme functies<\/a> (closures) de variabelen die zijn gedefinieerd in de parent scope inheritten. Dit doen ze met behulp van de use taalconstructie, zoals je hieronder kan zien:<\/p>\n Echter, met PHP 7.4 worden de variabelen die zijn gedefinieerd in de parent scope, impliciet vastgelegd op waarde<\/strong> (implicit by-value scope binding). We kunnen dus de hele functie die je boven zag, als volgt schrijven:<\/p>\n De variabele die is gedefinieerd in de parent scope kan gebruikt worden in de arrow functie, alsof we gebruik maken van De nieuwe syntax is een grote verbetering van de taal, omdat de code beter leesbaar en te onderhouden is. We kunnen ook parameter en return types<\/a> gebruiken, standaard waarden, argumentlijsten met variabele lengtes (variadic functions<\/a>), we kunnen pass en return door verwijzing, etc. Ten slotte kunnen short closures ook gebruikt worden in class methodes en maken ze net als normale closures gebruik van de $this variabele.<\/p>\n Deze RFC is goedgekeurd met 51 tegen 8 stemmen en kunnen deze daarom verwachten in de lijst met toevoegingen van PHP 7.4.<\/p>\n De coalesce operator<\/a> ( Wat deze code doet is redelijk eenvoudig: hij haalt de aangevraagde parameter op en stelt een standaardwaarde in als deze niet bestaat<\/strong>. De bovenstaande lijn met code is vrij eenvoudig, maar wat nou als we het voorbeeld van de RFC nemen, een die een veel meer variabele namen heeft?<\/p>\n Op de lange termijn is deze lijn met code lastig te onderhouden. Met de introductie van de null coalescing assignment operator<\/strong> \u00a0( Als de waarde van de linker parameter Dit voorstel heeft het gehaald met 37 stemmen voor en 4 stemmen tegen.<\/p>\n Argument type declarations, ook wel type hints genoemd, maken het mogelijk om het type van een variabele te specificeren, die naar verwachting wordt doorgegeven aan een functie of een class method. Type hints bestaan al sinds PHP 5 en sinds PHP 7.2<\/a> is het ook mogelijk om deze te gebruiken samen met het object data type. Type hints krijgen met PHP 7.4 een enorme boost door de support voor first-class property type declarations<\/a> mogelijk te maken. Hieronder een erg simpel voorbeeld:<\/p>\n Alle typen worden ondersteund, met uitzondering van De RFC legt de reden uit waarom Het void type wordt niet ondersteund, omdat dit niet zinvol is en een onduidelijke semantiek heeft.<\/p><\/blockquote>\n Het callable type wordt niet ondersteund, omdat zijn gedrag contextafhankelijk is.<\/p><\/blockquote>\n We kunnen dus veilig gebruiken: Types kunnen gebruikt worden op statische properties:<\/p>\n Ook is het mogelijk ze te gebruiken met de Het is mogelijk om standaard property values in te stellen, die natuurlijk overeen moeten komen met het gedeclareerde property type, maar alleen nullable properties kunnen een standaard Hetzelfde type is van toepassing op alle eigenschappen binnen \u00e9\u00e9n enkele declaratie:<\/p>\n Wat gebeurt er als je een fout maakt in het property type? Bekijk de volgende code:<\/p>\n In de code hierboven hebben we een string property type vastgelegd, maar een array als property value ingesteld. In een dergelijk scenario krijgen we de volgende Fatal error:<\/p>\n Deze RFC is goedgekeurd met 70 tegen 1 stemmen.<\/p>\n\n Met deze RFC<\/a> introduceert PHP 7.4 de class WeakReference<\/a>, waarmee programmeurs een verwijzing naar een object kunnen behouden zonder dat die verhindert het object zelf wordt vernietigd.<\/p>\n Momenteel ondersteunt PHP Weak References door een extensie als pecl-weakref te gebruiken. De nieuwe API anders dan de gedocumenteerde WeakRef class.<\/p>\n Hier is een voorbeeld van de auteur<\/a> van dit voorstel, Nikita Popov:<\/p>\n De eerste Deze RFC is aangenomen met 28 tegen 5 stemmen.<\/p>\n Variance<\/a> is een eigenschap van class hi\u00ebrarchie\u00ebn die beschrijven hoe de types van een type constructor subtypen<\/a> be\u00efnvloeden. Over het algemeen kan een type constructor het volgende zijn:<\/p>\n Momenteel heeft PHP vooral invariant parameters en return types, met enkele uitzonderingen. Deze RFC stelt voor om ook covariance en contravariance toe te staan op parameter types en return types, waarbij ze ook een aantal voorbeelden geven.<\/p>\n Hier is een voorbeeld van covariant return type<\/strong>:<\/p>\n En hier is een voorbeeld van contravariant parameter type<\/strong>:<\/p>\n Lees de RFC<\/a> voor een nadere beschouwing van covariance en contravariance in PHP 7.4.<\/p>\n Deze RFC is aangenomen met 39 tegen 1 stemmen.<\/p>\n Het voorstel van Dmitry Stogov<\/a> is een van onze favorieten, omdat het voor een aanzienlijke performanceboost zal zorgen. Preloading<\/strong> is het proces van het laden van bibliotheken en frameworks in de OPCache<\/a> bij module-initialisatie (lees hier meer over de PHP lifecycle<\/a>)<\/p>\n Dit is hoe preloading werkt – in de woorden van Dmitry:<\/p>\n Bij het opstarten van de server – voordat de eerste applicatiecode wordt uitgevoerd – kunnen we een bepaalde reeks PHP-bestanden in het geheugen laden – en de inhoud ervan “permanent beschikbaar” maken voor alle volgende aanvragen die door die server worden geleverd. Alle functies en classes die in deze bestanden zijn gedefinieerd, zijn direct beschikbaar voor verzoeken, precies zoals interne entiteiten.<\/p><\/blockquote>\n Deze bestanden worden bij het opstarten van de server geladen, worden nog v\u00f3\u00f3r de eerste applicatie uitgevoerd en blijven beschikbaar voor elk toekomstig verzoek. Voor prestaties is dit geweldig.<\/p>\n Preloading wordt beheerd door een specifieke Er is echter wel een nadeel. Deze wordt ook duidelijk vermeld in de RFC:<\/p>\n De voorgeladen bestanden blijven voor altijd in het opcache-geheugen opgeslagen. Het wijzigen van hun bijbehorende bronbestanden zal geen effect hebben zonder het opnieuw opstarten van de server.<\/p><\/blockquote>\n Alle functies die zijn gedefinieerd in vooraf geladen bestanden worden echter permanent geladen in PHP function en class tables en blijven beschikbaar voor elk toekomstig verzoek. Dit zal ongetwijfeld leiden tot significante prestatieverbeteringen, zelfs al zijn deze verbetering aanzienlijk variabel.<\/p>\n Je kan in de offici\u00eble Preloading RFC-pagina<\/a> meer lezen over de beperkingen en uitzonderingen van preloading.<\/p>\n Er is nog een ander voorstel<\/a> van Nikita Popov die met een overweldigende meerderheid is aangenomen.<\/p>\n Momenteel hebben we twee verschillende mechanismen voor aangepaste serialisatie van objecten in PHP:<\/p>\n Volgens Nikita kennen beide opties problemen die leiden tot complexe en onbetrouwbare code. Je kan meer lezen over dit onderwerp in het RFC<\/a>. In dit geval wil ik alleen vermelden dat het nieuwe serialisatiemechanisme deze problemen zou moeten voorkomen door twee nieuwe magic methods aan te bieden die de twee bestaande mechanismen combineren: Dit voorstel werd aangenomen met 20 tegen 7 stemmen.<\/p>\n De volgende functies\/functionaliteiten worden afgeschreven in PHP 7.4. Raadpleeg de PHP 7.4 Upgrade Notes<\/a> voor een uitgebreidere lijst met afschrijvingen.<\/p>\n Momenteel zijn in PHP de “+” en “-” arithmetic operators en kent de “.” string operator dezelfde prioriteit\u00a0 (lees hier meer over Operator Precedence<\/a>).<\/p>\n Bekijk de volgende regels eens:<\/p>\n In PHP 7.3 geeft deze code de volgende waarschuwing:<\/p>\n Dit omdat de aaneenschakeling van links naar rechts wordt ge\u00ebvalueerd. In principe had je dus net zo goed de volgende code kunnen schrijven:<\/p>\n Deze EFC<\/a> stelt voor om de voorrang van operatoren te wijzingen, waardoor “.” een lagere voorrang heeft dan de “+” en “-” operatoren, zodat toevoegingen en aftrekkingen altijd uitgevoerd worden v\u00f3\u00f3r de tekenreeksaaneenschakeling. Die regel code moet gelijk zijn aan het volgende:<\/p>\n Dit is een voorstel in twee stappen:<\/p>\n Beide voorstellen zijn met een ruime meerderheid aangenomen.<\/p>\n In PHP is de ternaire operator, in tegenstelling tot veel andere talen, links-associatief. Volgens Nikita Popof kan dit verwarrend zijn voor programmeurs die tussen verschillende talen schakelen.<\/p>\n Momenteel is in PHP de volgende code correct:<\/p>\n Dit wordt ge\u00efnterpreteerd als:<\/p>\n En dit kan leiden tot foutmeldingen, omdat het net doet wat we willen dat het doet. Deze RFC stelt voor om het gebruik van linkse associativiteit voor ternaire operatoren af te schaffen en ontwikkelaars te dwingen om haakjes te gebruiken.<\/p>\n Ook dit is een voorstel in twee stappen:<\/p>\n Dit voorstel heeft het gehaald met 35 stemmen voor en 10 stemmen tegen.<\/p>\n PHP is de meest gebruikte server-side programmeertaal op het web. Volgens W3Techs<\/a> gebruikt 78,9% van alle website PHP – gemeten op 2 december 2019 en op sites waarvan ze de programmeertaal van de server konden vaststellen.<\/p>\n Helaas gebruikt nog steeds 44,0% van alle websites PHP 5<\/a> (waarvan de server-side programmeertaal bekend is). Als je het aantal gebruikers toevoegt dat nog steeds PHP 7.0 en 7.1 gebruikt<\/a>, blijkt dat een grote meerderheid van websites niet-ondersteunde versies van PHP gebruikt.<\/p>\n Volgens de offici\u00eble WordPress Stats-pagina<\/a> gebruikt maar liefst 64% van alle WordPress-websites niet-ondersteunde PHP-versies. Slechts iets meer dan 13% gebruikt PHP 7.3<\/a>. En de nieuwste versie, PHP 7.4, heeft nog niet eens een verschijning gemaakt. Je ziet dat een grote meerderheid van de gebruikers, meer dan 23%, nog steeds op PHP 5.6. loopt.<\/p>\n We raden je ten zeerste aan om je host te vragen om een ondersteunde versie van PHP<\/a>, bij voorkeur volgens de offici\u00eble vereisten van WordPress<\/a>. Op moment van schrijven, mei 2019, vereist WordPress:<\/p>\n Uit het oogpunt van performance zijn bovenstaande cijfers voornamelijk ontmoedigend, simpelweg omdat PHP 7 aanzienlijk sneller is. Dit zeggen de statistieken:<\/p>\n\n
Wat is nieuw in PHP in PHP 7.4?<\/h2>\n
Vergeet array_merge: PHP 7.4 introduceert Spread Operator in Array Expression<\/h3>\n
function test(...$args) { var_dump($args); }\ntest(1, 2, 3);<\/code><\/pre>\n$arr = [...$args];<\/code><\/pre>\narray_merge<\/code>. Dat is niet alleen omdat spread operator een taalstructuur is en array_merge<\/code> een functie is, maar ook omdat de optimalisatie van compilatietijd kan worden gebruikt voor constant arrays.<\/p><\/blockquote>\narray_merge<\/code> functie alleen arrays ondersteunt.<\/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>\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>\nuse($var)<\/code> en het is niet mogelijk om een variabele van de parent scope te wijzigen.<\/p>\nNull Coalescing Assignment Operator<\/h3>\n
??<\/code>), toegevoegd met PHP 7, komt van pas wanneer we een ternary operator moeten gebruiken in combinatie met isset()<\/code>. Het retourneert de eerste operand, mits deze bestaat en niet NULL<\/code> is. Anders wordt de tweede operand geretourneerd. Hier is een voorbeeld:<\/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>) wil deze RFC\u00a0<\/a> het voor ontwikkelaars mogelijk maken om intu\u00eftiever code te schrijven. Dus in plaats van de bovenstaande code te schrijven, kunnen we nu het volgende schrijven:<\/p>\n$this->request->data['comments']['user_id'] ??= 'value';<\/code><\/pre>\nnull<\/code> is, dan wordt de waarde van de rechter parameter gebruikt.
\nLet wel op: de coalesce operator is een comparison operator, ??=<\/code> is een assignment operator.<\/p>\nTyped Properties 2.0<\/h3>\n
class User {\n\tpublic int $id;\n\tpublic string $name;\n}<\/code><\/pre>\nvoid<\/code> en callable<\/code>:<\/p>\npublic int $scalarType;\nprotected ClassName $classType;\nprivate ?ClassName $nullableClassType;<\/code><\/pre>\nvoid<\/code> en callable<\/code> niet worden ondersteund:<\/p>\nbool<\/code>, int<\/code>, float<\/code>, string<\/code>, array<\/code>, object<\/code>, iterable<\/code>, self<\/code>, parent<\/code>, de naam van een class of interface, en\u00a0nullable<\/a>\u00a0types<\/a> (?type<\/code>).<\/p>\npublic static iterable $staticProp;<\/code><\/pre>\nvar<\/code> notatie.<\/p>\nvar bool $flag;<\/code><\/pre>\nnull<\/code> waarde hebben:<\/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
$object = new stdClass;\n$weakRef = WeakReference::create($object);\n\nvar_dump($weakRef->get());\nunset($object);\nvar_dump($weakRef->get());<\/code><\/pre>\nvar_dump<\/code> print object(stdClass)#1 (0) {}<\/code>, terwijl de tweede var_dump<\/code> zorgt voor NULL<\/code>,\u00a0 omdat het object waarnaar verwezen wordt, is verwijderd.<\/p>\nCovariant Returns en Contravariant Parameters<\/h3>\n
\n
interface Factory {\n\tfunction make(): object;\n}\n\nclass UserFactory implements Factory {\n\tfunction make(): User;\n}<\/code><\/pre>\ninterface Concatable {\n\tfunction concat(Iterator $input); \n}\n \nclass Collection implements Concatable {\n\t\/\/ accepts all iterables, not just Iterator\n\tfunction concat(iterable $input) {\/* . . . *\/}\n}<\/code><\/pre>\nPreloading<\/h3>\n
![\"PHP](\"https:\/\/kinsta.com\/nl\/wp-content\/uploads\/sites\/7\/2019\/05\/php-lifecycle.png\")
php.ini<\/code> richtlijn: opcache.preload<\/code>. Deze richtlijn specificeert een PHP-script dat moet worden gecompileerd en uitgevoerd bij het opstarten van de server. Dit bestand kan ook worden gebruikt om extra bestanden te preloaden, door ze toe te voegen of via de functie opcache_compile_file ()<\/code> (lees meer in de PHP-documentatie<\/a>).<\/p>\nNieuwe aangepaste Object Serialization Mechanism (SPL)<\/h3>\n
\n
__sleep()<\/code> and __wakeup()<\/code> magic methods<\/li>\nSerializable<\/code> interface<\/li>\n<\/ul>\n__serialize()<\/code>\u00a0en\u00a0__unserialize()<\/code>.<\/p>\nAfschaffingen<\/h3>\n
De precedence van de concatenation operator wijzigen<\/h4>\n
echo \"sum: \" . $a + $b;<\/code><\/pre>\nWarning: A non-numeric value encountered in \/app\/types.php on line 4<\/code><\/pre>\necho (\"sum: \" . $a) + $b;<\/code><\/pre>\necho \"sum: \" . ($a + $b);<\/code><\/pre>\n\n
Afschaffing van de left-associative ternaire operator<\/h4>\n
$b = $a == 1 ? 'one' : $a == 2 ? 'two' : $a == 3 ? 'three' : 'other';<\/code><\/pre>\n$b = (($a == 1 ? 'one' : $a == 2) ? 'two' : $a == 3) ? 'three' : 'other';<\/code><\/pre>\n\n
Wat betekent PHP 7.4 voor WordPress-gebruikers?<\/h2>\n
![\"PHP](\"https:\/\/kinsta.com\/nl\/wp-content\/uploads\/sites\/7\/2019\/06\/php-versions-1.png\")
![\"Ondersteunde](\"https:\/\/kinsta.com\/nl\/wp-content\/uploads\/sites\/7\/2018\/06\/ondersteunde-php-versies-1.png\")
![\"WordPress](\"https:\/\/kinsta.com\/nl\/wp-content\/uploads\/sites\/7\/2020\/08\/wordpress-php-versie-statistiken.png\")
\n
PHP 7 prestaties<\/h3>\n
\n
![\"WordPress](\"https:\/\/kinsta.com\/nl\/wp-content\/uploads\/sites\/7\/2018\/12\/wordpress-5-0-php-benchmarks-1.png\")