PHP 8 - Nya funktioner, förbättringar, och potentiella problem med WordPress

Marten Gülink Senast uppdaterad den 11 januari 2021
10 Min.
php 8 större uppdatering
Senast uppdaterad den 11 januari 2021


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!

Viktiga nya 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, förbättringar, 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.

Youtube

Genom att läsa in videon accepterar du YouTubes sekretesspolicy.
Läs mer

Ladda ner video

PGlmcmFtZSBsb2FkaW5nPSJsYXp5IiBzcmM9Imh0dHBzOi8vd3d3LnlvdXR1YmUtbm9jb29raWUuY29tL2VtYmVkL2RXSDY1cG1uc3JJIiBhbGxvdz0iYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGNsaXBib2FyZC13cml0ZTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZSIgYWxsb 3dmdWxsc2NyZWVuPSIiIHdpZHRoPSI1NjAiIGhlaWdodD0iMzE1IiBmcmFtZWJvcmRlcj0iMCI+PC9pZnJhbWU+

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 påstår tillåter statisk returtyp återkomsten av det speciella klassnamnet "statisk" från en metod: "Det statiska specialklassnamnet i PHP refererar till klassen som en metod faktiskt kallades på, även om metoden ärvs. Detta kallas "sen statisk bindning" (LSB). Denna RFC föreslår att statiskt också kan användbart som returtyp (bredvid de redan användbara själv- och överordnade typerna)."

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

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 problemet genom att skapa en "svag" referens till motsvarande objekt. När objektet har tagits bort är alla variabler med referensen Svaga kartor 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

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

Om du vill WordPress till PHP 8? 

För välskrivna kodbaser eller kodbaser som har hållit sig uppdaterade med de senaste PHP-versionerna finns det inget stort problem [att migrera till PHP 8]. Verkligheten är dock att WordPress är inte en sådan kodbas.

Omar Reiss, yoast

Detta citat från Yoast " WordPress och PHP 8 Compatibility Report" antyder redan att du, som en WordPress User:in bör inte tas lätt med uppdateringen till PHP 8. Slutsatsen av rapporten förstärker detta antagande, eftersom Omar Reiss skriver: "Genom att bara undersöka en delmängd av att bryta förändringar i PHP 8 kan vi redan bekräfta att detta sannolikt kommer att orsaka stora brott på webbplatser med oklart ursprung för detta brott. Ofta uppstår felet på ett ställe, men orsakas av en plugin Eller theme på en annan plats, vilket gör dessa frågor svåra att felsöka."

Dessa kompatibilitetsproblem är också en anledning till att PHP 8 inte är omedelbart RAIDBOXES Instrumentpanel för våra kunder: finns tillgänglig inomhus. Särskilt efter stora uppdateringar är det alltid meningsfullt att Plugin Utvecklare: ge tillräckligt med tid för eventuella justeringar och vänta tills vidare. Så snart vi kan se till att det finns en standard WordPress Installation ger inga problem och PHP 8 körs stabilt och utförande på vårt system, vi kommer naturligtvis att tillhandahålla PHP 8.

Om du redan har tillgång till PHP 8 och den nya versionen är ansluten till din WordPress webbplats bör du först skapa en säkerhetskopia, som du gjorde före någon uppdatering. Så här skaffar du en ny PHP-version RAIDBOXES test korrekt kan du läsa det här hjälpcenterinlägget (här med exemplet PHP 7.2).

Vår slutsats

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.

Som webbutvecklare på RAIDBOXES Marten arbetar alltid med nya funktioner för våra kunder. På " wp unboxed " han gör också poäng med sin kunskap om webbutveckling, WordPress och vår instrumentpanel. Och även på sin fritid gillar han att hantera självhotell och de senaste trenderna på Internet.

Liknande artiklar

Kommentarer om den här artikeln

Skriva en kommentar

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