PHP 8.2: Vad är nytt?

PHP 8.2 är på väg att släppas. Kanske blir det den version som gör att en uppgradering till PHP 8 verkar tilltalande för alla. Låt oss prata om vad utvecklare kan se fram emot med PHP 8.2 och förbereda sig för sin senaste version. Men först, låt oss snabbt gå igenom alla PHP-versioner och förändringar genom åren.

Översikt över tidigare versioner

PHP 7,4

Typade egenskaper

<?php
klass Användare {
    publik int $id;
    publik sträng $namn;
}
?>

Funktioner för pilar

<?php
$factor = 10;
$nums = array_map(fn($n) => $n * $factor, [1, 2, 3, 4]);
// $nums = array(10, 20, 30, 40);
?>

Begränsad kovarians mellan returtyper och kontravarians mellan argumenttyper

<?php
klass A {}
klass B utökar A {}

klass Producent {
    public function metod(): A {}
}
klassen ChildProducer utökar Producer {
    publik funktion method(): B {}
}
?>

Null coalescing tilldelningsoperator

<?php
$array['key'] ??= computeDefault();
// är ungefär likvärdigt med
if (!isset($array['key'])) {
    $array['key'] = computeDefault();
}
?>

Uppackning av inre matriser

<?php
$parts = ['äpple', 'päron'];
$fruits = ['banana', 'orange', ...$parts, 'watermelon'];
// ['banana', 'orange', 'apple', 'pear', 'watermelon'];
?>

Anpassad serialisering av objekt

<?php
// Returnerar en array som innehåller alla nödvändiga tillstånd för objektet.
public function __serialize(): array;

// Återställer objektets tillstånd från den givna dataarrayen.
public function __unserialize(array $data): void;
?>

PHP 8,0

PHP 8.0 släpptes i november 2020 och gav oss de bästa funktionerna hittills, vilket inkluderar:

Namngivna argument

htmlspecialchars($string, double_encode: false); 

Attribut

klass PostsController
{
    #[Route("/api/posts/{id}", methods: ["GET"])]
    public function get($id) { /* ... */ }
}

Konstruktörens egenskap marknadsföring

klass Punkt {
  publik funktion __construct(
    public float $x = 0,0,
    public float $y = 0.0,
    offentlig float $z = 0.0,
  ) {}
}

Unionstyper

klass Nummer {
  offentlig funktion __construct(
    privat int|float $nummer
  ) {}
}

new Number('NaN'); // Typfel

Matchningsuttryck

echo match (8.0) {
  '8.0' => "Åh nej!",
  8.0 => "Det här är vad jag förväntade mig",
};
//> Det här är vad jag förväntade mig

Nullsäker operatör

$country = $session?->user?->getAddress()?->country;

PHP 8.1

Uppräkningar

enum Status
{
    fall Utkast;
    fall Publicerad;
    fall Arkiverad;
}
funktion acceptStatus(Status $status) {...}

Readonly Egenskaper

klass BloggData
{
    public readonly Status $status;

    publik funktion __construct(Status $status)
    {
        $this->status = $status;
    }
}

Förstklassig anropsbar syntax

$foo = $this->foo(...);

$fn = strlen(...);

Nytt i initialiserare

klass Service
{
    private Logger $logger;

    publik funktion __construct(
        Logger $logger = new NullLogger(),
    ) {
        $this->logger = $logger;
    }
}

Rena korsningstyper

function count_and_iterate(Iterator&Countable $value) {
    foreach ($value as $val) {
        echo $val;
    }

    count($value);
}

Fibrer

$response = $httpClient->request('https://example.com/');
print json_decode($response->getBody()->buffer())['code'];

PHP 8.2

PHP 8.2 introducerar ytterligare förändringar som syftar till att göra utvecklarens liv enklare och optimera hans arbete ännu mer. Nedan följer en lista över nya funktioner.

Skrivskyddade klasser

En av de största förbättringarna i den nya versionen av PHP är möjligheten att direkt skapa en skrivskyddad klass. En klass som beskrivs med den här funktionen kommer automatiskt att sprida den till sina variabler. DTO-klasser kommer nu att se snygga och rena ut!

läsbar klass InvoiceDTO
{
    offentlig funktion __construct(
        publik UUID $uuid,
        publik Utfärdare 1TP60Utfärdare,
        publik DateTime $issuedAt,
    ) {}
}

Avskaffa dynamiska egenskaper

Den andra stora förändringen är borttagandet av dynamiska variabler i klasser. Följande implementering kommer att kasta en deprecation i PHP 8.2 och FelException i framtida version av PHP.

klass MyUser
{
    public string $name;
}
(...)
$myUser->name = 'Namn'; // OK
$myUser->surname = 'Efternamn'; // föråldrad / errorexception

Det är värt att nämna att klasser som implementerar __get och __set metoder och klasser som direkt ärver från stdKlass kan fortfarande implementera magiska metoder utan några hinder.

Här hänvisar jag dig också till en intressant tråd på GitHub, där PHP-CS-utvecklare diskuterar denna förändring och behovet av att ändra sitt populära verktyg för den nya versionen av språket.

Sist men inte minst kan du inaktivera detta beteende via Annotation.

#[TillåtDynamiskaEgenskaper]
klass MyUser
{
    public string $namn;
}

$myUser->efternamn = "Efternamn"; // OK

Nya fristående typer: noll, sant, och falska

Hittills har funktioner som alltid returnerat ett sant eller falska värde måste beskrivas med ett bool typ.

function alwaysTrue(): bool { return true; }

Från och med nu kan vi använda sant och falska som enkla typer i återlämnade värden från funktioner.

funktion alwaysTrue(): true { returnerar true; }

Disjunktiva normalformstyper

(DNF) är ett standardiserat sätt att organisera booleska uttryck. Specifikt innebär det att ett booleskt uttryck struktureras till en OR-serie av AND:ar. När det tillämpas på typdeklarationer möjliggör det ett standardiserat sätt att skriva kombinerade Union- och Intersection-typer som parsern kan hantera.

Det är en stor förändring, eftersom vi nu kan ha nollställbara intersektionstyper, till exempel:

funktion getFullName((HasName&HasSurname)|null $user) { ... }

Konstanter i egenskaper

Jag är inte en stor förespråkare för att använda Traits och en sådan förändring är rent kosmetisk för mig, särskilt eftersom det inte tillåter dig att använda Trait-värden utan att initialisera objektet.

trait Foo {
    public const FLAG_1 = 1;
    skyddad const FLAG_2 = 2;
    privat const FLAG_3 = 2;

    public function doFoo(int $flags): void {
        if ($flags & self::FLAG_1) {
            echo 'Fick flagga 1';
        }
        if ($flags & self::FLAG_2) {
            echo "Fick flagga 2";
        }
        if ($flags & self::FLAG_3) {
            echo "Fick flagga 3";
        }
    }
}

Redigering av parametrar i gamla spår

En av de viktigaste förändringarna som jag ser fram emot. I den senaste versionen av PHP kommer vi att kunna markera variabler som KänsligParameterVärde. Varför skulle vi göra det?

PHP: s stackspår i undantag är mycket användbara för felsökning, men de låter dig förhandsgranska parametervärden. Låt oss till exempel föreställa oss PDO kod används för att ansluta till en databas. Debugspårningen skulle se ut på följande sätt:

PDO Undantag: SQLSTATE[HY000] [2002] Ingen sådan fil eller katalog i /var/www/html/test.php:3
Stack spårning:
#0 /var/www/html/test.php(3): PDO->__construct('mysql:host=loca...', 'root', 'password')
#1 {huvud}

Efter användning av Annotation #[KänsligParameter] kommer vår stackspårning inte längre att visa variabelns värde.

funktionstest(
    $foo,
    #[KänsligParameter] $bar,
    $baz
) {
    kasta ett nytt undantag("Fel");
}

test('foo', 'bar', 'baz');

/*
Fatalt fel: Oavslutat undantag: Fel i test.php:8
Stackspårning:
#0 test.php(11): test('foo', Object(SensitiveParameterValue), 'baz')
#1 {huvud}
  kastad i test.php på rad 8
*/

Hämta egenskaper för enum i const-uttryck

Som författaren säger
Det primära motivet för denna ändring är att tillåta hämtning av namn- och värdeegenskaperna på platser där enum-objekt inte är tillåtna, som array-nycklar. Vi skulle kunna arbeta med matriser så att de kan utökas för att tillåta enum eller alla objekt som nycklar, men att tillåta att hämta egenskaper hos enum är enklare.

enum A: sträng {
    fall B = 'B';
    const C = [self::B->värde => self::B];
}

Datumfunktioners returtyper

Tidigare fungerade statiska metoder så här:

DateTime::createFromImmutable(): DateTime
DateTimeImmutable::createFromMutable(): DateTimeImmutable 

I PHP 8.2 kommer det att ändras till:

DateTime::createFromImmutable(): statisk
DateTimeImmutable::createFromMutable(): statisk

Detta är en avgörande förändring för biblioteksskapare och/eller alla anpassade implementationer av DateTime.

Avveckla och ta bort `utf8_encode` och `utf8_decode`

Det var två funktioner som inte fyllde sitt syfte, eftersom de bara konverterade mellan ISO-8859-1 och UTF-8. PHP Manual föreslår att du använder mb_konvertera_kodning istället.

Lokaloberoende konvertering av ärenden

Lokalkänslighet beskrivs bäst av författaren till RFC:

Före PHP 8.0 ställdes PHP:s lokala in från miljön. När en användare installerar Linux frågar programmet vilket språk som ska användas. Användaren kanske inte fullt ut inser konsekvenserna av detta beslut. Det ställer inte bara in användargränssnittsspråket för inbyggda kommandon, det ändrar också genomgående hur stränghanteringen i C-biblioteket fungerar. Till exempel skulle en användare som väljer "turkiska" när han installerar Linux upptäcka att program som anropar toupper('i') skulle få den prickade versalen I (U+0130, "İ").

I en tid med standardiserade textbaserade protokoll är naturligt språk en minoritetstillämpning för skiftlägeskonvertering. Men även om användaren skulle vilja ha skiftlägeskonvertering på naturligt språk skulle det vara osannolikt att de skulle lyckas med strtolower(). Detta beror på att strängen bearbetas en byte i taget och varje byte matas till C-bibliotekets tolower(). Om indata är UTF-8, det överlägset mest populära moderna valet, kommer strtolower() att mangla strängen och vanligtvis producera ogiltig UTF-8 som utdata.

PHP 8.0 slutade att respektera locale-miljövariablerna. Så locale är alltid "C" om inte användaren uttryckligen anropar setlocale(). Detta innebär att huvuddelen av den bakåtkompatibla förändringen redan ligger bakom oss. Alla program som är beroende av systemets locale för att göra skiftlägeskonvertering av äldre 8-bitars teckenuppsättningar skulle ha brutits av PHP 8.0.

Vad det betyder är att alla nedanstående funktioner kommer att göra ASCII-fallkonvertering från PHP.8.2:
strtolower, strtoupper, stristr, stripos, strripos, första, ucfirst, uc-ord, str_ireplace

Avveckla ${} stränginterpolering

Vi har många sätt att bädda in variabler i strängar i PHP:
- Direkt inbäddning av variabler ("$foo")
- Hakparenteser utanför variabeln ("{$foo}")
- Hakparenteser efter dollartecknet ("${foo}")
- Variabelvariabler ("${expr}", motsvarande (sträng) ${expr})

För att undvika förvirring och felaktig användning kommer dessa inte att fungera längre:

"Hej ${world}";
Föråldrad: Att använda ${} i strängar är föråldrat

"Hej ${(världen)}";
Föråldrad: Användning av ${} (variabelvariabler) i strängar är föråldrad

Sammanfattning

Detta är inte alla de förändringar som PHP 8.2 kommer att erbjuda oss. Tyvärr fick vi fortfarande inte stöd för generiska typer, enligt vad Nikita sa skulle monomorfiserade generiska typer lägga till för mycket prestandakostnader, och reifierade generiska typer kräver många ändringar i hela kodbasen. Vad som dock är märkbart är disciplinen och visionen hos Produkt. De ändringar som införts i de olika språkversionerna blir allt tydligare, och den intresserade kan konstatera att PHP rör sig i rätt riktning både när det gäller förenkling av syntax och stöd för nyheter. Jag förväntar mig att vi redan nästa år kommer att se anropsbar som en giltig typ.