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

Mårten 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 vilket fall PHP 8 verkligen leder 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 funktion frysa sedan juli. Fram till publicering på Den 26 november inga fler tillägg var tillåtna. En speciell egenskap hos denna version är att vi hoppar över PHP 7.5 och gå direkt till PHP 8. Och detta hopp är förknippat med en mängd funktioner. 

En av de vanligaste frågorna om PHP 8 som WordPress Användare:Inställning är det förmodligen: Kommer PHP 8 förbättra resultatet av min hemsida?

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

När PHP uppgraderades från version 5 till version 7, det var en enorm prestandaökning. Men med PHP 8, kommer du märker inte en allmän prestandaförbättring, såvida inte din ansökan beräknar många matematiska funktioner (se vår sektion på JIT-kompilatorn). Detta beror främst på att koden optimering av PHP är redan mycket väl etablerad.

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

Key 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. Unionstyp 
  8. Blandade typer 

Jit(just-in-time)-kompilatorn (Rfc)

När PHP-kod körs görs det oftast genom att kompilera till virtuella satser 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å CPU. För program som är starkt beroende av matematiska funktioner, bör detta förbättra prestanda. Detta är dock inte att vänta för det genomsnittliga webbprogrammet (se diagram). 

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

För 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

PGlmcmFtZSBzcmM9Imh0dHBzOi8vd3d3LnlvdXR1YmUtbm9jb29raWUuY29tL2VtYmVkL2RXSDY1cG1uc3JJIiBhbGxvdz0iYWNjZWxlcm9tZXRlcjsgYXV0b3B l0ZTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZSIgYWxsb3dmdWxsc2NyZWVuPSIHdpZHROPHI1NjAiGhlaodD0iMzE1

I grund och botten, det kokar ner till din ansökan 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:ing: ing, 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, jag förklara nedan. 

Vi fortsätter med de nya funktionerna:

Attribut v2 (Rfc, Rfc)

En av nyheterna i PHP 8 (som har lett till omfattande diskussioner i PHP-communityn) är attribut – kända på många andra språk som "annotation". Attribut ersätter insättning 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 ni kan föreställa er, med hjälp av kod kommentarer för att tillämpa metadata var inte idealiskt, men det fungerade. Lyckligtvis kommer vi inte längre att ha detta problem. 

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

Här är några exempel från RFC om 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 punkt, det är värt att notera att RFC för attribut har genomgått vissa förändringar sedan den ursprungligen utformades, visar ansträngning och överväganden som lagts ned på den här uppdateringen. 

Namngivna argument (Rfc)

Namngivna argument ge dig mer flexibilitet när du ringer funktioner. Hittills behöver 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 position almentos, vilket förbättrar läsbarheten av koden: 

htmlspecialchars($string, double_encode: false);

Matcha uttryck (Rfc)

Matcha uttryck lösa några långvariga problem i funktionaliteten hos föregångaren Switch. 

Jämförelseoperator

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

Returvärde

Switch-satser genererar ofta ett värde som behövs senare i programflödet. Detta kan förhindra att det här värdet sätts i Switch-satsen, vilket då kan orsaka problem i PHP-skriptet. Dessutom är syntaxen för satsen Switch svår att läsa för kapslade switch-programsatser.

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

Det nya matchuttrycket eliminerar detta problem genom att tilldela returvärdet direkt för varje matchningsgren(=>), vilket är mer intuitivt. 

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

Fallthrough

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

Match har implementerat en implicit brytning efter varje gren (=>). Flera villkor kan nu utföras av 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 kasta uttalande blivit ett uttryck. Detta innebär att, tekniskt sett, kasta kan nu returnera ett värde. Detta är till hjälp i den meningen att kasta nu kan användas på många fler ställen, såsom .B Arrow Functions eller Coalesce Operators. 

Pilfunktioner:

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

Coalesce Operatö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)

Hur denna RFC säger, Statisk Returtyp tillåter retur av den speciella klassnamnet "statisk" från en metod: "Den statiska speciella klass namn i PHP avser klassen en metod faktiskt kallades på, även om metoden ärvs. Detta kallas "sen statisk bindning" (LSB). Detta RFC föreslår att göra statisk också användbar som en returtyp (bredvid de redan användbara själv och överordnade typer)."  

Statisk kan dock inte användas som en del av en parameter i det här fallet. Den statiska avkastningen kommer att referera till den klass som anropades. 

Unionstyper (Rfc)

Unionstyper låta dig deklarera den typ av värde du förväntar dig av en indata. På vissa språk kallas detta för ett schema. Detta stöds syntaktiskt av användningen av  | (t.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, de genomförs med hjälp av phpdoc annotering metod. 

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 i stället för bara en, vilket möjliggör en högre grad av återanvändningsbarhet av koden.

Blandade typer (Rfc)

I nyare PHP-versioner var det möjligt att deklarera den förväntade typen av in- och returdata. 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. Mixd Typer försöker nu lösa detta problem.

A mixed typ skulle vara motsvarigheten till array|bool|callable|int|float|null|object|resource|string

Här är ett exempel från RFC dokumentär om hur man 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, asort, arsort, uasort, ksort, krsort, uksort, array_multisort).

Jag skulle rekommendera att du gör detta i den RFC Dokumentär att läsa och jämföra det med ditt program, som att ändra denna funktionalitet från instabil till stabil sortering skulle kunna negativt påverka din kod.

Byggkonstruktör Fastighetsförmedling Promotion (Rfc)

Den här funktionen är utformad för att hjälpa till att snabba upp arbetsflödet för Dev och minska fel. För närvarande kräver definitionen av ett objekt av värden en uppsättning av kokplattor, som visas nedan från RFC Dokumentation kan ses:

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 Operator (Rfc)

Det finns en ny operatör i detta block! 

Istället för den !== null klassiska, har vi nu fått detta: ?-> . Det verkar konstigt i början, men om man ser på det ur synvinkel av kedjning av "if-uttalanden", då ansökan blir ganska tydlig: 

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

Denna ganska fina nya funktion 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)

I PHP, när du ställer in en variabel till värdet av ett objekt, skapas vanligtvis en referens till det objektet, men inte ett nytt objekt. 

I så fall kan du sluta med många referenser till ett objekt, men bara ett objekt. Problemet är att när det är dags att ta bort detta objekt, php räknar antalet referenser som detta objekt har. Och om det är mer än en, php kommer att vägra att ta bort detta objekt. 

Svaga Kartor löser detta problem genom att skapa en "svag" referens till motsvarande objekt. När objektet har tagits bort anges alla variabler med den svaga maps-referensen till det här objektet till noll. 

Icke-fånga fångster (Rfc)

En try-catch block är ganska häftigt när det gäller felrapportering och nu finns det ett ännu snabbare sätt att genomföra 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 din Catch Undantag 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 catch block.

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

}

Annat PHP 8 läsmaterial

Om du vill veta mer om frisläppandet av PHP 8 eller bläddra i RFC kodexemplen själv, bara ta en titt på den officiella Meddelande om utgivning

Är du redo för PHP 8? 

Ingen utvecklare är ett av uppdateringar med stora förändringar (vi minns WordPress 5.0 och Gutenberg ) där det finns risk för att din kod kommer att bryta och vänta 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 på PHP och PHP WordPress i nästa kapitel). 

Men om du har en äldre PHP-version som används, bör du kontrollera listan över föråldrade funktioner innan du uppdaterar. I den PHP "Bilagor" Dokumentation hittar du en komplett 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 stannat up-to-date med de senaste PHP-versionerna, det finns inte ett 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 den Yoast "WordPress och PHP 8 Kompatibilitetsrapport" föreslår redan att du, som WordPress User:in bör inte tas lättvindigt 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 vi kunde redan bekräfta detta sannolikt kommer att orsaka stora brott på platser med oklart ursprung som går sönder. Ofta kommer felet att uppstå 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 omedelbart RAIDBOXES Dashboard för våra kunder: är tillgänglig inomhus. Särskilt efter större uppdateringar, är det alltid meningsfullt att Plugin Utvecklare: ge tillräckligt med tid för eventuella justeringar och vänta tills dess. Så snart vi kan se till att det finns en standard WordPress Installation ger inga problem och PHP 8 körs stabil och performant på vårt system, kommer vi naturligtvis att ge 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 innan någon uppdatering. Hur får man en ny PHP-version RAIDBOXES test korrekt kan du i detta Helpcenter inlägg (se exemplet med PHP 7.2) här.

Vår slutsats

PHP 8 är ett stort steg framåt jämfört med sin föregångare versioner. Även om du inte omedelbart kan se 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 det, det är stabilt och din WordPress hoster är tillgänglig. Den nya versionen är en naturlig progression, och genom att implementera den förr snarare än senare skapar du en stabil 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 innovationer av PHP 8 med den här artikeln. Har du ytterligare frågor om detta ämne? Använd kommentarsfunktionen. Du vill ha fler tips om ämnet WordPress , Webbdesign och mer? Följ oss sedan på TwitterFacebook eller via vår 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 sina kunskaper om webbutveckling, WordPress och vår instrumentpanel. Och även på sin fritid han gillar att ta itu med själv-hosting och de senaste trenderna på Internet.

Kommentarer om den här artikeln

Skriv en kommentar

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