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!

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). 

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

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. 

Genoemde argumenten(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);

Wedstrijduitdrukkingen(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
    },
}

Uitdrukkingen gooien(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. 

Pijlfuncties: 

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

Coalesce Operators: 

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

Ternaire operatoren:

// $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 van de speciale klassenaam "static" van een methode toe: "De speciale klassenaam static in PHP verwijst naar de klasse waarop een methode daadwerkelijk is aangeroepen, zelfs als de methode is geërfd. Dit staat bekend als "late statische binding" (LSB). Deze RFC stelt voor om static ook bruikbaar te maken als retourneertype (naast de al bruikbare types self en parent)."

Statisch kan in dit geval echter niet gebruikt worden als onderdeel van een parameter. De statische terugkeer zal verwijzen naar de klasse die werd aangeroepen. 

Bondstypen(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  | (bijv. 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;
    }
}

Bekijk voor wat meer context over het gebruik 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 wordt gebruikt:

// 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

Sorteren stabiel maken(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 Bevordering(rfc)

Deze functie zou je dev workflow moeten helpen versnellen en fouten verminderen. Momenteel vereist het definiëren van een object van waarden een reeks boilerplates, zoals hieronder 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! 

Anstelle des klassischen <code>!== null</code> haben wir nun das bekommen: <code>?-></code>. Es scheint zunächst merkwürdig, aber wenn man es unter dem Gesichtspunkt der Verkettung von „if-Statements“ betrachtet, dann wird die Anwendung ziemlich deutlich: 

$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 lost dit probleem op door een "zwakke" verwijzing naar het bijbehorende object te maken. Zodra het object wordt verwijderd, worden alle variabelen met de Weak Maps verwijzing naar dit object op nul gezet. 

Niet-vangende vangsten(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 je meer wilt weten over de release van PHP 8 of zelf de RFC codevoorbeelden wilt bekijken, bekijk dan 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. 

WordPress bijwerken naar PHP 8? 

Dit citaat uit het Yoast"WordPress and PHP 8 Compatibility Report" suggereert al dat je als WordPress gebruiker 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 veroorzaakt op sites met een onduidelijke oorsprong van die breuken. Vaak treedt de fout op één plaats op, maar wordt hij veroorzaakt door een plugin of thema op een andere plaats, waardoor deze problemen moeilijk te debuggen zijn."

Deze compatibiliteitsproblemen waren ook de reden waarom PHP 8 niet onmiddellijk beschikbaar was voor onze klanten. Vooral na grote updates is het altijd verstandig om de ontwikkelaars van WordPress plugins voldoende tijd te geven om eventuele aanpassingen door te voeren en voorlopig af te wachten. Nu kun je je website eenvoudig bijwerken naar PHP 8 of PHP 8.1 via Raidboxes Dashboard . Hoe je een nieuwe PHP-versie goed test op Raidboxes wordt uitgelegd in dit Helpcenter artikel.

Onze conclusie over PHP 8

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.