PHP 8 - Nieuwe features, verbeteringen en potentiële problemen met WordPress

Marten Gülink Laatst bijgewerkt op 11.01.2021
10 Min.
php 8 grote update
Laatst bijgewerkt op 11.01.2021


PHP 8 is er! De major update werd uitgebracht op 26 november 2020 en brengt enkele fundamentele wijzigingen en vele nieuwe functies met zich mee. In welk geval PHP 8 echt tot een betere performance leidt en of je als WordPress-gebruiker al zou moeten updaten naar de nieuwe versie, legt RAIDBOXES ontwikkelaar Marten je uit.

Introductie in PHP 8 

PHP 8 werd voor het eerst aan zijn alfatesters voorgesteld op 18 juni 2020 en is sinds juli in een feature freeze. Er mochten dus geen nieuwe toevoegingen worden gedaan tot de release op 26 november. Een uniek kenmerk van deze release is dat we PHP 7.5 overslaan en direct overgaan op PHP 8. En deze sprong komt met een heleboel functies. 

Een van de meest voorkomende vragen over PHP 8 die WordPress gebruikers waarschijnlijk stellen is: Zal PHP 8 de prestaties van mijn website verbeteren?

Het antwoord op deze vraag is (zoals zo vaak): "Het hangt ervan af..."

Toen PHP werd opgewaardeerd van versie 5 naar versie 7, was er een enorme prestatieverbetering. Met PHP 8 zult u echter geen algemene prestatieverbetering zien, tenzij uw toepassing veel wiskundige functies berekent (zie onze sectie over de JIT compiler). Dit komt vooral omdat de codeoptimalisatie van PHP al zeer goed is ingeburgerd.

Maar wie zegt dat performance beperkt is tot de 'compile time'? Van mijn kant zou ik als ontwikkelaar de prestaties op verschillende manieren meten, waaronder de functies die beschikbaar zijn om goed gestructureerde code te schrijven. En PHP 8 zit vol met nieuwe goodies. Dus, laten we beginnen!

De belangrijkste nieuwe feature-updates in PHP 8 

PHP 8 heeft acht nieuwe hoofdfeatures die ik je graag kort wil voorstellen: 

  1. De JIT Compiler 
  2. Attributes
  3. Named Arguments
  4. Match Expressions 
  5. Throw Expressions
  6. Static Return Type 
  7. Union Type 
  8. Mixed Types 

De JIT (just-in-time) compiler(rfc)

Wanneer PHP Code wordt uitgevoerd, gebeurt dit meestal door het te compileren naar virtuele instructies die op een virtuele machine uitgevoerd worden. JIT zal dit veranderen door de code te compileren naar x86-machinecode en deze code vervolgens direct op de CPU uit te voeren. Voor toepassingen die sterk afhankelijk zijn van wiskundige functies zou dit de prestaties moeten verbeteren. Dit wordt echter niet verwacht voor gemiddelde webapplicaties (zie grafiek). 

PHP 8 - Nieuwe features, verbeteringen en potentiële problemen met WordPress
Bron

Bekijk de volgende video als je een voorbeeld wilt zien van de prestatieverhoging die via JIT kan worden bereikt.

YouTube

Door de video te laden, accepteer je het privacybeleid van YouTube.
Meer informatie

Laad video

PGlmcmFtZSBsb2FkaW5nPSJsYXp5IiBzcmM9Imh0dHBzOi8vd3d3LnlvdXR1YmUtbm9jb29raWUuY29tL2VtYmVkL2RXSDY1cG1uc3JJIiBhbGxvdz0iYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGNsaXBib2FyZC13cml0ZTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZSIgYWxsb3dmdWxsc2NyZWVuPSIiIHdpZHRoPSI1NjAiIGhlaWdodD0iMzE1IiBmcmFtZWJvcmRlcj0iMCI+PC9pZnJhbWU+

In principe komt het erop neer dat je toepassing met de nieuwe versie soepeler verloopt, als je PHP voor een arbeidsintensieve, wiskundige taak gebruikt. Maar als je PHP gebruikt zoals de meeste WordPress gebruikers dat doen, zul je geen grote veranderingen opmerken. Meer over wat PHP 8 voor de beheerders WordPress websites betekent, zal ik het hieronder uitleggen. 

Dan gaan we verder met de volgende features:

Attributen v2(rfc, rfc)

Een van de nieuwe kenmerken in PHP 8 (die heeft geleid tot uitgebreide discussies in de PHP-community) zijn attributes - in veel andere talen bekend als "annotations". In PHP 8 vervangen attributen de Docblocks-metadataopslag. Dit is wat je tot nu toe moest gebruiken om metadata voor klassen, methoden, functies en argumenten op een gestructureerde manier te declareren. 

Zoals je je kunt voorstellen, was het gebruik van codecommentaar om metadata toe te passen niet ideaal, maar het werkte wel. Gelukkig hebben we dit probleem niet meer. 

Attributen kunnen met de Syntax #[...] gedeclareerd worden.

Hier zijn enkele voorbeelden uit de RFC van hoe attributen op verschillende datatypen kunnen worden toegepast.

#[ExampleAttribute]
class Foo
{
    #[ExampleAttribute]
    public const FOO = 'foo';
 
    #[ExampleAttribute]
    public $x;
 
    #[ExampleAttribute]
    public function foo(#[ExampleAttribute] $bar) { }
}
 
$object = new #[ExampleAttribute] class () { };
 
#[ExampleAttribute]
function f1() { }
 
$f2 = #[ExampleAttribute] function () { };
 
$f3 = #[ExampleAttribute] fn () => 1;

Op dit punt is het de moeite waard om op te merken dat de RFC voor attributen enkele wijzigingen heeft ondergaan sinds de oorspronkelijke opzet, wat de moeitje en inspanningen laat zien die in deze update is gestoken is. 

Named Arguments(rfc)

Genoemde argumenten geven je meer flexibiliteit bij het aanroepen van functies. Tot nu toe moest je een functie aanroepen en elk argument in de door de functie gespecificeerde volgorde doorgeven. 

// Using positional arguments:
array_fill(0, 100, 50);

Met Named Arguments kun je een naam voor elke parameter definiëren. En nu kan de volgorde wisselen, zoals hieronder beschreven: 

// Using named arguments:
array_fill(start_index: 0, num: 100, value: 50);

Ze kunnen ook als volgt worden opgeroepen:

array_fill(value: 50, num: 100, start_index: 0);

Een mengvorm van de twee is ook mogelijk, waarbij benoemde parameters en positionele argumenten kunnen worden gecombineerd, wat de leesbaarheid van de code ten goede komt: 

htmlspecialchars($string, double_encode: false);

Overeenstemmingsuitdrukkingen(rfc)

Match Expressions is bedoeld om enkele reeds lang bestaande problemen in de functionaliteit van zijn voorganger, Switch, op te lossen. 

Comparison Operator

Switch gebruikt van een type converterende vergelijkingsoperator (==), wat problemen kan veroorzaken. Match gebruikt daarentegen een strikte vergelijkingsoperator (===), onafhankelijk van strict_types.

Return Value

Switch instructies genereren vaak een waarde die later in het programmaverloop nodig is. Het kan gebeuren dat deze waarde niet aan de Switch instructies gegeven wordt, wat tot problemen in het PHP-script kan leiden. Bovendien maakt de syntaxis van de Switch instructie het moeilijk om geneste Switch instructies te lezen.

switch (1) {
    case 0:
        $y = 'Foo';
        break;
    case 1:
        $y = 'Bar';
        break;
    case 2:
        $y = 'Baz';
        break;
}
 
echo $y;
//> Bar

De nieuwe Match uitdrukking lost dit probleem op door direct de retourwaarde voor elke Match tak (=>) toe te wijzen, wat intuïtiever is. 

echo match (1) {
    0 => 'Foo',
    1 => 'Bar',
    2 => 'Baz',
};
//> Bar

Fallthrough

Als een Switch statement na elke case een break heeft, gaat het door naar de volgende case, zelfs als de code zou breken. Dit is zo ontworpen dat de Switch functies meerdere codeblokken achter elkaar kunnen uitvoeren. Dit is in het verleden echter een veelvoorkomende bron van fouten geweest. 

Match heeft een impliciete break ingevoerd na elke tak (=>). Meerdere condities kunnen nu worden uitgevoerd door het plaatsen van komma's tussen elke conditie: 

match ($x) {
    1, 2 => {
        // Same for 1 and 2
    },
    3, 4 => {
        if ($x === 3) {
            // Only 3
        }
        // Same for 3 and 4
    },
}

Werp uitdrukkingen(rfc)

In PHP 8 is het throw statement een uitdrukking geworden. Dit betekent dat throw nu technisch gezien een waarde kan teruggeven. Dit is nuttig in die zin dat de throw nu op veel meer plaatsen kan worden gebruikt, zoals de Arrow Functions of Coalesce Operators. 

Pijl Functies: 

$callable = fn() => throw new Exception();

Operatoren samenvoegen: 

// $value is non-nullable.
$value = $nullableValue ?? throw new InvalidArgumentException();
 
// $value is truthy.
$value = $falsableValue ?: throw new InvalidArgumentException();

Ternary Operators:

// $value is only set if the array is not empty.
$value = !empty($array)
    ? reset($array)
    : throw new InvalidArgumentException();

Statisch terugkeertype(rfc)

Zoals deze RFC stelt, staat Static Return Type de terugkeer toe van de speciale klassenaam "static" van een methode: "De speciale klassenaam "static" in PHP verwijst naar de klasse waarop een methode werkelijk werd aangeroepen, zelfs indien de methode wordt geërfd. Dit staat bekend als "late statische binding" (LSB). Deze RFC stelt voor om static ook bruikbaar te maken als return type (naast de reeds bruikbare self en parent types)."

Static kan in dit geval echter niet als deel van een parameter worden gebruikt. De static return zal verwijzen naar de klasse die werd aangeroepen. 

Unie Types(rfc)

Union Types maken het voor jou mogelijk om het type waarde te declareren dat je van een invoer verwacht. In sommige talen wordt dit een schema genoemd. Dit wordt syntactisch door het gebruik van  | (b.v. string|array|int) gedefinieerd. Maar daar houdt de magie niet op, want je kunt ook gedefinieerde klassen gebruiken zoals:

class MyClass {

}
function myFunction(string|array|int|MyClass){

}

Unie-types worden reeds gebruikt in PHP. Ze worden echter geïmplementeerd met de phpdoc-annotatiemethode, zoals hieronder wordt getoond. 

class Number {
    /**
     * @var int|float $number
     */
    private $number;
 
    /**
     * @param int|float $number
     */
    public function setNumber($number) {
        $this->number = $number;
    }
 
    /**
     * @return int|float
     */
    public function getNumber() {
        return $this->number;
    }
}

Voor een beetje meer context over het gebruik, bekijk dit voorbeeld uit de RFC:

class Number {
    private int|float $number;
 
    public function setNumber(int|float $number): void {
        $this->number = $number;
    }
 
    public function getNumber(): int|float {
        return $this->number;
    }
}

Dit alles komt erop neer dat je meerdere invoertypes voor dezelfde functie kunt gebruiken in plaats van slechts één, wat een hogere mate van herbruikbaarheid van de code mogelijk maakt.

Gemengde Types(rfc)

In recente versies van PHP was het mogelijk om het verwachte type van invoer- en retourgegevens aan te geven. PHP heeft echter niet altijd Types ondersteund, en dat is een probleem. In sommige gevallen werd een type weggelaten of gewoon vergeten. GemengdeTypes probeert nu dit probleem op te lossen.

Een mixed type zou het equivalent zijn van array|bool|callable|int|float|null|object|resource|string

Hier is een voorbeeld uit de RFC documentatie van hoe dit gebruikt wordt:

// Valid example
 
class A
{
    public function foo(int $value) {}
}
 
class B extends A
{
    // Parameter type was widened from int to mixed, this is allowed
    public function foo(mixed $value) {}
}

Extra PHP 8 features

Maak sorteren stabiel(rfc)

Stabiliteit wordt toegevoegd aan alle functies die onder Sorteren vallen (bijvoorbeeld.

sort, rsort, usort, asort, arsort, uasort, ksort, krsort, uksort, array_multisort).

Ik raad u aan dit te lezen in de RFC docs en het te vergelijken met uw toepassing, aangezien het veranderen van deze functionaliteit van onstabiel naar stabiel sorteren uw code negatief zou kunnen beïnvloeden.

Constructor Eigendom Promotie(rfc)

Deze functie zou uw dev workflow moeten helpen versnellen en fouten verminderen. Momenteel vereist het definiëren van een object van waarden een reeks boilerplates, zoals hieronder getoond in de RFC documentatie:

class Point {
    public float $x;
    public float $y;
    public float $z;
 
    public function __construct(
        float $x = 0.0,
        float $y = 0.0,
        float $z = 0.0,
    ) {
        $this->x = $x;
        $this->y = $y;
        $this->z = $z;
    }
}

Bij deze methode moeten de eigenschappen drie keer worden herhaald. De verbetering daarvan staat in onderstaande korte formule: 

class Point {
    public function __construct(
        public float $x = 0.0,
        public float $y = 0.0,
        public float $z = 0.0,
    ) {}
}

Zero Safe Operator(rfc)

Er is een nieuwe operator in dit block! 

In plaats van de klassieker <code>!== nul</code>, hebben we nu dit: <code>?->.</code> Het lijkt op het eerste gezicht vreemd, maar als je het bekijkt vanuit het oogpunt van de aaneenschakeling van "if-Statements", wordt de toepassing vrij duidelijk: 

$country =  null;
 
if ($session !== null) {
    $user = $session->user;
 
    if ($user !== null) {
        $address = $user->getAddress();
 
        if ($address !== null) {
            $country = $address->country;
        }
    }
}
 
// do something with $country
$country = $session?->user?->getAddress()?->country;
 
// do something with $country

str_contains(rfc)

Deze vrij mooie nieuwe functie geeft een booleaanse waarde (true/false) uit wanneer een string in een andere string wordt gevonden. Er zijn twee argumenten nodig, namelijk string die doorzocht moet worden en de string die gezocht moet worden.

str_contains('php8', '8'); // true
str_contains('php8', 'wordpress'); // false

Voor nog bruikbaarder stringfilters moet je de volgende nieuwe functies bekijken:

str_starts_with('haystack', 'hay'); // true
str_ends_with('haystack', 'stack'); // true

Deze twee zullen beide een booleaans resultaat opleveren en werken op dezelfde manier als str_contains().

Zwakke kaarten(rfc)

Wanneer je in PHP een variabele op de waarde van een object instelt, wordt meestal wel een verwijzing naar dat object gemaakt, maar geen nieuw object. 

In dit geval kun je dus veel verwijzingen naar een object hebben, maar slechts één object. Het probleem hiermee is: wanneer het tijd is om dat object te verwijderen, zal PHP het aantal referenties tellen dat dat object heeft. En als het er meer dan één is, zal PHP weigeren dat object te verwijderen. 

Zwakke kaarten lossen dit probleem op door een "zwakke" verwijzing naar het overeenkomstige object te maken. Zodra het object is verwijderd, worden alle variabelen met de Weak Maps verwijzing naar dat object op nul gezet. 

Vangsten zonder vangst(rfc)

Een try-catch-block is al vrij ingenieus als het om Error Reporting gaat en nu is er een nog snellere manier om dit te implementeren. En nee, het zal de leesbaarheid niet echt beïnvloeden. 

De "old school" manier betekende dat je je Catch Exception moest doorgeven aan een variabele als deze:

function catchMeWhenIFall(){
	try {
        throw new Exception('NOPE - GRAVITY');
    } catch (Exception $e) {
        return $e->getMessage();
    }

}

Maar nu hoef je de variabele niet meer te definiëren die moet worden doorgegeven aan je catch-block.

try {
	throw new Exception('FOO!');
 catch  (){
	//Do some code here
 }

}

Meer PHP 8 leesvoer

Als u meer wilt weten over de release van PHP 8 of de RFC code voorbeelden zelf wilt bekijken, kijk dan even naar de officiële release aankondiging

Ben je al klaar voor PHP 8? 

Geen enkele ontwikkelaar is een fan van updates met grote veranderingen (we herinneren ons WordPress 5.0 en Gutenberg), waar het risico bestaat dat je code breekt en uren werk of een volledige rebuild op je staat te wachten. Als je code echter al goed werkt met PHP 7.4 zou je geen problemen moeten hebben met PHP 8 (meer over PHP en WordPress in het volgende hoofdstuk). 

Als u echter een oudere versie van PHP gebruikt, moet u de lijst van verouderde functies controleren voordat u gaat updaten. Zie de PHP-documentatie "Bijlagen" voor een volledige lijst van vroegere kenmerken, wijzigingen en problemen bij het updaten van de ene PHP-versie naar de volgende. 

Moet je je WordPress updaten naar PHP 8? 

For well-typed codebases or codebases which have stayed up-to-date with the latest PHP versions, there isn’t a big problem [to migrate to PHP 8]. The reality, however, is that WordPress is not such a codebase.

Omar Reiss, yoast

Dit citaat uit het Yoast "WordPress and PHP 8 Compatibility Report" suggereert al dat je als WordPress gebruiker:in de update naar PHP 8 niet lichtvaardig moet behandelen. De conclusie van het rapport versterkt deze veronderstelling, zoals Omar Reiss schrijft: "Door slechts een subset van brekende veranderingen in PHP 8 te onderzoeken, konden we al bevestigen dat dit waarschijnlijk grote breuken zal veroorzaken op sites waarvan de oorsprong onduidelijk is. Vaak treedt de fout op de ene plaats op, maar wordt deze veroorzaakt door een plugin of theme op een andere plaats, waardoor deze problemen moeilijk te debuggen zijn."

Deze compatibiliteitsproblemen zijn ook een reden waarom PHP 8 niet onmiddellijk beschikbaar is in het RAIDBOXES dashboard voor onze klanten. Vooral na grote updates is het altijd een goed idee om de ontwikkelaars van Plugin voldoende tijd te geven om de nodige aanpassingen door te voeren en voorlopig af te wachten. Zodra wij er zeker van kunnen zijn dat er geen problemen zijn met een standaardinstallatie op WordPress en PHP 8 stabiel en performant draait op ons systeem, zullen wij PHP 8 uiteraard beschikbaar stellen.

Als u al toegang heeft tot PHP 8 en de nieuwe versie wilt testen met uw WordPress website, moet u - zoals voor elke update - eerst een back-up maken. Hoe u een nieuwe PHP-versie correct kunt testen op RAIDBOXES kunt u lezen in dit Helpcenter artikel (hier met PHP 7.2 als voorbeeld).

Onze conclusie

PHP 8 is een grote stap voorwaarts ten opzichte van de voorgaande versies. Hoewel je misschien niet onmiddellijk een dramatische verbetering in de prestaties ziet (afhankelijk van hoe je PHP 8 gebruikt), moet je de update ten minste overwegen nadat je het hebt getest, het stabiel is en het beschikbaar is bij je WordPress hoster. De nieuwe versie is een natuurlijke vooruitgang en door liever vroeger dan later te implementeren, creëer je een solide basis voor toekomstige uitbreiding, groei en prestatieverbeteringen.

Meer vragen over PHP 8?

Ik hoop dat ik u met dit artikel kennis heb kunnen laten maken met de opwindende nieuwe functies van PHP 8. Heb je meer vragen over dit onderwerp? Voel je vrij om de commentaarfunctie te gebruiken. Wil je meer tips over WordPress , webdesign en meer? Volg ons dan op Twitter, Facebook of via onze nieuwsbrief.

Als webontwikkelaar bij RAIDBOXES werkt Marten voortdurend aan nieuwe features voor onze klanten. Op "wp unboxed" scoort hij ook met zijn kennis van webdevelopment, WordPress en ons dashboard. En ook in zijn vrije tijd houdt hij zich graag bezig met self-hosting en de nieuwste trends op het internet.

Gerelateerde artikelen

Reacties op dit artikel

Laat een opmerking achter

Jouw e-mailadres zal niet worden gepubliceerd. Verplichte velden zijn met een * gemarkeerd.