php 8 större uppdatering

PHP 8 – Nya funktioner och potentiella problem med WordPress

PHP 8 är här! Den stora uppdateringen släpptes den 26 november 2020 och ger oss några grundläggande förändringar samt många nya funktioner. I så fall leder PHP 8 verkligen till bättre prestanda och om du är WordPress User:in bör redan uppdatera till den nya versionen, förklarar vår utvecklare Marten för dig.

Introduktion till PHP 8 

PHP 8 introducerades först den 18 juni 2020 och har varit i en funktionsfrysning sedan juli. Inga nya tillägg kunde läggas till förrän den 26 november. En speciell egenskap hos denna version är att vi hoppar över PHP 7.5 och går direkt till PHP 8. Och detta hopp är förknippat med en mängd olika funktioner. 

En av de vanligaste frågorna om PHP 8 som WordPress Användare:Ställa in det är förmodligen: Kommer PHP 8 att förbättra prestandan på min webbplats?

Svaret på denna fråga är (som så ofta): "Det beror på ..."

När PHP uppgraderades från version 5 till version 7 var det en enorm prestandaökning. Men med PHP 8 ser du inte en allmän prestandaförbättring ominte ditt program beräknar många matematiska funktioner (se vårt avsnitt om JIT-kompilatorn). Detta beror främst på att kodoptimeringen av PHP redan är mycket väletablerad.

Men vem säger ens att prestandan är begränsad till kompileringstiden? För min del skulle jag som utvecklare mäta prestanda på en mängd olika sätt, inklusive de funktioner som är tillgängliga för mig för att skriva välstrukturerad kod. Och PHP 8 är full av nya godsaker. Så låt oss komma igång!

Funktionsuppdateringar i PHP 8 

PHP 8 har åtta nya huvudfunktioner som jag skulle vilja presentera för dig: 

  1. JIT-kompilatorn 
  2. Attribut
  3. Namngivna argument
  4. Matcha uttryck 
  5. Kasta uttryck
  6. Statisk returtyp 
  7. Typ av union 
  8. Blandade typer 

JIT-kompilatorn (just-in-time)(rfc)

När PHP-kod körs görs det vanligtvis genom att kompilera till virtuella uttalanden som körs på en virtuell dator. JIT kommer att ändra detta genom att sammanställa koden till x86-maskinkod och sedan köra den koden direkt på processorn. För applikationer som är starkt beroende av matematiska funktioner bör detta förbättra prestandan. Detta kan dock inte förväntas för det genomsnittliga webbprogrammet (se diagram). 

PHP 8 – Nya funktioner och potentiella problem med WordPress
Källkod

Ett exempel på den prestandaförbättring som JIT kan uppnå är det bäst att titta på följande video.

I grund och botten handlar det om att ditt program går smidigare med den nya versionen när du använder PHP för en arbetsintensiv, matematisk uppgift. Men om du gillar de flesta PHP WordPress Användare:inuse, då kommer du inte att märka några stora förändringar. Mer om vad PHP 8 gör för operatörer: WordPress Webbplatser betyder, förklarar jag nedan. 

Vi fortsätter med de nya funktionerna:

Attribut v2 (rfc, rfc)

En av innovationerna i PHP 8 (som har lett till omfattande diskussioner i PHP-samhället) är attribut - på många andra språk som kallas "anteckning". Attribut ersätter insättningen av metadata med docblocks i PHP 8. Du har varit tvungen att använda detta för att deklarera metadata för klasser, metoder, funktioner och argument på ett strukturerat sätt. 

Som du kan föreställa dig var det inte idealiskt att använda kodkommentarer för att tillämpa metadata, men det fungerade. Lyckligtvis kommer vi inte längre att ha detta problem. 

Attribut kan användas med Syntax #[...] deklareras.

Här är några exempel från RFC på hur attribut kan tillämpas på olika datatyper.

#[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;

Vid denna tidpunkt är det värt att notera att RFC för attribut har genomgått några förändringar sedan den ursprungligen utformades, vilket visar ansträngningen och övervägandena som lagts in i den här uppdateringen. 

Namngivna argument (rfc)

Namngivna argument ger dig mer flexibilitet när du anropar funktioner. Hittills måste du anropa en funktion och skicka varje argument i den ordning som anges av funktionen. 

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

Med namngivna argument kan du definiera ett namn för varje parameter. Och nu, som beskrivs nedan, kan dessa kallas utom i ordning: 

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

De kan också kallas enligt följande:

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

Det är också möjligt att använda en hybrid av båda, vilket gör det möjligt att kombinera namngivna parametrar och positioneringsalmentos, vilket förbättrar kodens läsbarhet: 

htmlspecialchars($string, double_encode: false);

Matcha uttryck (rfc)

Match Expressions är utformade för att lösa några långvariga problem i funktionaliteten hos föregångaren Switch. 

Jämförelseoperator

Switch använder en typkonverterande jämförelseoperator (==), vilket kan orsaka problem. Däremot använder Match en strikt jämförelseoperator (===), oavsett strict_types.

Returvärde

Växelsatser genererar ofta ett värde som behövs senare i programflödet. Detta kan förhindra att det här värdet anges i Switch-satsen, vilket sedan kan orsaka problem i PHP-skriptet. Dessutom är syntaxen för Switch-satsen svår att läsa för kapslade växelsatser.

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

Det nya matchningsuttrycket eliminerar det här problemet genom att tilldela returvärdet direkt för varje matchningsgren(=>), vilket är mer intuitivt. 

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

Genomfall

Om en växelutdrag inte bryts efter varje enskilt fall fortsätter den till nästa fall, även om koden bryts. Detta utformades så att växelfunktionerna kan köra flera kodblock i följd. Detta har dock hittills varit en vanlig felkälla. 

Matchning har implementerat en implicit paus efter varje gren (=>). Flera villkor kan nu köras med kommatecken mellan varje villkor: 

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

Kasta uttryck (rfc)

I PHP 8 har kastsatsen blivit ett uttryck. Det innebär att kastet tekniskt sett nu kan ge ett värde tillbaka. Detta är användbart i den meningen att kast nu kan användas på många fler platser, till exempel .B Arrow Functions eller Coalesce Operators. 

Pilfunktioner: 

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

Sammanslagningsoperatörer: 

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

Ternary Operatörer:

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

Statisk returtyp (rfc)

Som denna RFC anger tillåter statisk returtyp retur av det speciella klassnamnet "statisk" från en metod: "Det statiska specialklassnamnet i PHP refererar till klassen som en metod faktiskt anropades, även om metoden är ärvd. Detta kallas "sen statisk bindning" (LSB). Denna RFC föreslår att statisk också ska kunna användas som en returtyp (bredvid de redan användbara själv- och överordnade typerna)."

Statisk kan dock inte användas som en del av en parameter i det här fallet. Den statiska returen refererar till klassen som anropades. 

Unionstyper (rfc)

Unionstyper gör att du kan deklarera vilken typ av värde du förväntar dig av en indata. På vissa språk kallas detta ett schema. Detta stöds syntaktiskt av användningen av  | (e.B. string|array|int) definierad. Men magin slutar inte där, eftersom du också kan använda definierade klasser som:

class MyClass {

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

}

Unionstyper används redan i PHP. Men som visas nedan implementeras de med hjälp av phpdoc-anteckningsmetoden. 

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;
    }
}

För lite mer sammanhang om användning, kolla in det här exemplet från 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;
    }
}

Allt detta innebär att du kan använda flera indatatyper för samma funktion istället för bara en, vilket möjliggör en högre grad av återanvändbarhet av koden.

Blandade typer (rfc)

I nyare PHP-versioner var det möjligt att deklarera den förväntade typen av indata och returnera data. PHP har dock inte alltid stött typer, och det är ett problem. I vissa fall har en typ utelämnats eller helt enkelt glömts bort. Mixed Types försöker nu lösa detta problem.

A mixed skulle motsvara array|bool|callable|int|float|null|object|resource|string

Här är ett exempel från RFC-dokumentären om hur du använder detta:

// 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) {}
}

Ytterligare PHP 8-funktioner

Gör sorteringen stabil(rfc)

Stabilitet läggs till i alla funktioner som faller under Sortera (tillexempel.

sortera, rsort, usort, aort, arsort, uasort, ksort, krsort, uksort, array_multisort).

Jag rekommenderar att du läser detta i RFC-dokumentären och jämför den med din applikation, eftersom ändring av denna funktionalitet från instabil till stabil sortering kan påverka din kod negativt.

Konstruktörsfastighetsbefordran (rfc)

Den här funktionen är utformad för att hjälpa till att påskynda ditt Dev-arbetsflöde och minska fel. För närvarande kräver definitionen av ett värdeobjekt en uppsättning pannplattor, vilket kan ses från RFC-dokumentationen nedan:

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;
    }
}

Den här metoden kräver att egenskaperna upprepas tre gånger. Förbättringen är den korta formeln nedan: 

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

Nullsafe Operatör (rfc)

Det finns en ny operatör i det här kvarteret! 

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)

Den här ganska fina nya funktionen returnerar ett booleskt värde (sant/falskt) när en sträng hittas i en annan sträng. Detta kräver två argument, strängen att söka efter och strängen att söka efter.

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

För ännu mer användbara strängfilter bör du titta på följande nya funktioner:

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

Dessa två kommer båda att ge ett booleskt resultat och arbeta på samma sätt som str_contains().

Svaga kartor (rfc)

När du anger en variabel till värdet för ett objekt skapas vanligtvis en referens till objektet, men inte ett nytt objekt. 

I det här fallet kan du få många referenser till ett objekt, men bara ett objekt. Problemet är att när det är dags att ta bort det här objektet räknar PHP antalet referenser som det här objektet har. Och om det är mer än en, kommer PHP att vägra att ta bort det här objektet. 

Svaga kartor löser detta problem genom att skapa en "svag" referens till motsvarande objekt. När objektet har tagits bort är alla variabler med den svaga mappningsreferensen till det här objektet inställda på noll. 

Fångster som inte fångas (rfc)

Ett try-catch-block är ganska fantastiskt när det gäller felrapportering och nu finns det ett ännu snabbare sätt att implementera det. Och nej, det kommer inte att påverka läsbarheten. 

Sättet för den "gamla skolan" innebar att du var tvungen att passera ditt catch exception till en variabel som denna:

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

}

Men nu behöver du inte längre definiera variabeln som ska skickas till ditt fångstblock.

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

}

Annat PHP 8-läsmaterial

Om du vill veta mer om lanseringen av PHP 8 eller bläddra i RFC-kodexemplen själv, ta bara en titt på det officiella releasemeddelandet

"*" visar obligatoriska fält

Samtycke*
Det här fältet är avsett för validering och bör inte ändras.

Är du redo för PHP 8? 

Ingen utvecklare är ett av uppdateringar med stora förändringar (vi kommer ihåg WordPress 5.0 och Gutenberg ) där det finns risk för att koden går sönder och väntar på timmar av arbete eller en fullständig ombyggnad. Men om din kod redan har fungerat rent med PHP 7.4., bör du inte ha några problem med PHP 8 (mer om PHP och PHP WordPress i nästa kapitel). 

Men om du har en äldre PHP-version i bruk bör du kontrollera listan över föråldrade funktioner innan du uppdaterar. I PHP-dokumentationen "Appendices" hittar du en fullständig lista över tidigare funktioner, ändringar och problem med uppdateringen från en PHP-version till nästa. 

Uppdatera WordPress till PHP 8? 

Detta citat från Yoast "WordPress och PHP 8 Compatibility Report" föreslår redan att du som WordPress-användare inte ska ta uppdateringen till PHP 8 lätt. Slutsatsen i rapporten förstärker detta antagande, eftersom Omar Reiss skriver: "Genom att bara undersöka en delmängd av brytande förändringar i PHP 8 kunde vi redan bekräfta att detta sannolikt kommer att orsaka stora brott på platser med oklart ursprung till det brottet. Ofta kommer felet att uppstå på ett ställe, men orsakas av ett plugin eller tema på en annan plats, vilket gör dessa problem svåra att felsöka.

Dessa kompatibilitetsproblem var också anledningen till att PHP 8 inte var omedelbart tillgängligt för våra kunder. Speciellt efter större uppdateringar är det alltid vettigt att ge utvecklarna av WordPress-plugins tillräckligt med tid för eventuella justeringar och att vänta för tillfället. Nu kan du enkelt använda Raidboxes Dashboard Uppdatera din webbplats till PHP 8 eller PHP 8.1. Hur man skapar en ny PHP-version på Raidboxes korrekt testad förklarar vi i detta hjälpcenterinlägg.

Vår slutsats om PHP 8

PHP 8 är ett stort steg framåt jämfört med sina tidigare versioner. Även om du kanske inte omedelbart ser en dramatisk förbättring av prestanda (beroende på hur du använder PHP 8), bör du överväga uppdateringen - åtminstone efter att du har testat den är den stabil och din WordPress värd är tillgänglig. Den nya versionen är en naturlig utveckling, och genom att implementera den förr snarare än senare skapar du en solid grund för framtida expansioner, tillväxt och framtida prestandaförbättringar.

Fler frågor om PHP 8?

Jag hoppas att jag kunde presentera dig för de spännande innovationerna i PHP 8 med den här artikeln. Har du några fler frågor om detta ämne? Använd kommentarsfunktionen. Du vill ha fler tips om ämnet WordPress , Webbdesign och mer? Följ oss sedan på Twitter, Facebook eller via vårt nyhetsbrev.

Tyckte du om artikeln?

Med din recension hjälper du oss att förbättra vårt innehåll ytterligare.

Skriva en kommentar

Din e-postadress kommer inte att publiceras. Obligatoriska fält är markerade med *.