PHP 8.4: Aké zmeny a novinky prinesie nové péhápéčko? 🐘

17. november 2024 8 min čítania

Nová verzia PHP 8.4 prináša niekoľko zaujímavých zmien a noviniek. Prehľad tých najdôležitejších zmien, akými sú property hooks či asymetric visibilit, ti prinesiem v mojom krátkom článku.

Rok 2024 sa blíži ku koncu, a to neznamená nič iné ako to, že sa blíži release novej verzie PHP 8.4. Naplánovaná na 21. novembra, nová verzia PHP-čka prinesie so sebou viaceré novinky. V tomto článku ti ponúknem krátky výber tých najdôležitejších vychytávok, na ktoré sa môžeš tešiť už čoskoro vo svojom IDE-čku. Poďme na to!

Property hooks

Property hooks sú asi najviac hot fičúrkou, ktorú PHP 8.4 prinesie 😎 Inšpirované jazykmi ako Kotlin alebo Swift, property hooks ti umožnia zadefinovať get a set logiku pre properties pomocou novej syntaxe, bez nutnosti použiť metódy. To čo by v minulosti vyzeralo nejako takto:

 1class User
 2{
 3    private string $name;
 4 
 5    // get method
 6    public function getName(): string {
 7        return $this->name;
 8    }
 9 
10    // set method
11    public function setName(string $name): void {
12        $this->name = trim($name);
13    }
14}
15 
16$user = new User();
17$user->setName('  Erik ');
18echo $user->getName(); // Outputs: Erik

po novom môžeš vďaka property hooks napísať takto:

 1class User
 2{
 3    // methods replaced with property hooks
 4    public string $name {
 5        get => $this->name;
 6        set {
 7            $this->name = trim($value);
 8        };
 9    }
10}
11 
12$user = new User();
13$user->name = '  Erik ';
14echo $user->name; // Outputs: Erik

Na prvý pohľad trochu useless, a čo ešte tá syntax. Na to si človek bude nejaký čas zvykať.

Prečo sú teda property hooks také strašne hot? Je to hlavne preto, že ich môžeš použiť aj v interface-och 🔥. Doteraz si v starom dobrom PHP vedel pre interface zadefinovať iba metódy, a properties mali bohužiaľ smolu. Preto často interfaces obsahovali metódy, ktoré slúžili len ako glorifikované getre. A ty si musel potom implementovať tieto nekonečné metódy v každej implementácii daného interfacu. Eww:

 1// The old way
 2 
 3interface PaymentProcessor
 4{
 5    // to ensure we have string, we needed to use method
 6    public function getName(): string;
 7}
 8 
 9class Stripe implements PaymentProcessor
10{
11    // and then implement the method, although it is only a getter
12    public function getName(): string
13    {
14        return 'stripe';
15    }
16}
 1// The new way
 2 
 3interface PaymentProcessor
 4{
 5    // define property with get in interface
 6    public string $name { get; }
 7}
 8 
 9class Stripe implements PaymentProcessor
10{
11    // noice!
12    public string $name = 'stripe';
13}

Property hooks práve vďaka tomuto spojeniu s inteface-ami dokážu ušetriť nekonečné množstvo boilerplate kódu, a do budúcna určite zmenia PHP na aké sme zvyknutí.

Keďže sú property hooks dosť široká téma a majú mnoho využití, plánujem o nich napísať samostatný článok. Ak ťa táto téma zaujíma tak buď v strehu! 🫡

Asymetric visibility

Asymetric visbility vo mne vyvoláva zmiešané pocity, asi tak ako keď som videl prvý krát Roba Kazíka bez nafarbeného knírku.

Asymetric visibility prináša možnosť zadefinovať viditeľnost (aka visibility, teda public/private/protected) pre jednotlivé properties osobitne pre get/set. Zložitá veta, ale predstaviť si to môžeš pomerne jednoducho, napr. keby si mal public get metódu a private set metódu:

 1class User
 2{
 3    private string $name;
 4 
 5    public function getName(): string
 6    {
 7        return $this->name;
 8    }
 9 
10    private function setName(string $name): void
11    {
12        $this->name = $name;
13    }
14}

Po novom nemusíš používať metódy, ale vieš zadefinovať visibility priamo na property:

1class User
2{
3    public function __construct(
4        public private(set) string $name,
5    )
6    {}
7}

Áno, aj mňa táto syntax zasiahla a spôsobila mi ťažobu pri srdci. S odstupom času to až tak čierno nevidím. Podobne ako property hooks, tak aj asymetric visibility ušetrí veľa boilerplate kódu a nahradí písanie množstva metód. Čas ukáže ako moc si ľudia adaptujú túto novinku, verím však, že asymetric visibility bude mať podobnú genézu ako Robov knírek: človek si postupne zvykne a spomienky na časy čierneho plnofúzu mu pripomenie iba obal skvelého albumu Mojim najdrahším.

Nové array funkcie

S príchodom PHP 8.4 sa inžinierom podarilo pridať aj niekoľko nových funkcií pre prácu s poľami. Priznám sa, že nie som fanúšikom syntaxe pre PHP array funkcie (hlavne keď treba viaceré skombinovať, no veď vieš sám, je to bolesť). Preto používam poväčšine Laravel collections, a tak ma s príchodom týchto nových prírastkov do PHP prekvapilo, že vlastne doteraz takéto funkcie neexistovali. Poďme sa však pozrieť, aké funkcie to vlastne pribudli.

array_find

Funkcia array_find($array, $callback) vráti prvý element, ktorý pre danú $callback funkciu vráti TRUE:

 1$array = [
 2    'a' => 'dog',
 3    'b' => 'cat',
 4    'c' => 'cow',
 5    'd' => 'duck',
 6    'e' => 'goose',
 7    'f' => 'elephant'
 8];
 9 
10array_find($array, function (string $value) {
11    return strlen($value) > 4;
12}); // string(5) "goose"
13 
14array_find($array, function (string $value) {
15    return str_starts_with($value, 'f');
16}); // null
17 
18// Find the first animal where the array key is the first symbol of the animal.
19array_find($array, function (string $value, $key) {
20   return $value[0] === $key;
21});

array_find_key

Funkcia array_find_key($array, $callback) vráti kľúč (key) pre prvý element, ktorý pre danú $callback funkciu vráti TRUE. Čiže to isté ako array_find, iba dostaneš key.

 1$array = [
 2    'a' => 'dog',
 3    'b' => 'cat',
 4    'c' => 'cow',
 5    'd' => 'duck',
 6    'e' => 'goose',
 7    'f' => 'elephant'
 8];
 9 
10array_find_key($array, function (string $value) {
11    return strlen($value) > 4;
12}); // string(1) "e"
13 
14array_find_key($array, function (string $value) {
15    return str_starts_with($value, 'f');
16}); // null
17 
18array_find_key($array, function (string $value, $key) {
19   return $value[0] === $key;
20}); // string(1) "c"

array_any

Funkcia array_any($array, $callback) vracia hodnotu TRUE ak aspoň jeden element z daného poľa $array vráti pre $callback funkciu hodnotu TRUE. Ak pole $array neobsahuje ani jeden takýto prvok, funkcia vráti FALSE.

 1$array = [
 2    'a' => 'dog',
 3    'b' => 'cat',
 4    'c' => 'cow',
 5    'd' => 'duck',
 6    'e' => 'goose',
 7    'f' => 'elephant'
 8];
 9 
10// Check, if any animal name is longer than 5 letters.
11array_any($array, function (string $value) {
12    return strlen($value) > 5;
13}); // bool(true)
14 
15// Check, if any animal name is shorter than 3 letters.
16array_any($array, function (string $value) {
17    return strlen($value) < 3;
18}); // bool(false)

array_all

Funkcia array_all($array, $callback) vracia hodnotu TRUE ak všetky elementy z daného poľa $array vrátia pre $callback funkciu hodnotu TRUE. Ak pole $array obsahuje čo i len jeden prvok vracajúci false, tak celá funkcia array_all vráti FALSE.

 1$array = [
 2    'a' => 'dog',
 3    'b' => 'cat',
 4    'c' => 'cow',
 5    'd' => 'duck',
 6    'e' => 'goose',
 7    'f' => 'elephant'
 8];
 9 
10// Check, if all animal names are shorter than 12 letters.
11array_all($array, function (string $value) {
12    return strlen($value) < 12;
13}); // bool(true)
14 
15// Check, if all animal names are longer than 5 letters.
16array_all($array, function (string $value) {
17    return strlen($value) > 5;
18}); // bool(false)

HTML5 support pre DOM parser

Na krásne 10 výročie od vydania HTML5 sa konečne táto “novinka” dostala aj do PHP vo forme podpory pre DOM parser.

DOM parser slúži na parsovanie HTML dokumentov, avšak doterajšia implementácia v DOM extension podporovala iba verziu HTML4. To znamená, že pokiaľ si sa snažil pracovať s hociakou stránkou, ktorá nebola z doby kamennej, tak si mal smolu (a musel si použiť nejakú externú knižnicu). Tomu je však koniec, a smelo môžeš začať parsovať aj HTML5.

Ako sa hovorí, lepšie neskoro ako nikdy. Či?

Nová new syntax

Malá ale pekná fičúrka je podpora novej syntaxe pri vytváraní inštancií pre triedy. Po novom môžeš vynechať tzv. wrapping zátvorky:

1// Old
2(new User())->sayHello();
3 
4// New
5new User()->sayHello();

Čo si o novej syntaxi myslíš? Pre mnohých bude asi chvíľu trvať kým si na ňu zvyknú, prípadne ostanú pri starej so zátvorkami. Za mne ale dobrý!

Záver

Nové péhápko po dlhšej dobe prinesie niekoľko väčších zmien. Aj keď niektorým ľudia budú musieť prísť na chuť, je super vidieť, že sa jazyk posúva ďalej. Ja osobne sa zo zmien teším, a myslím si, že do budúcna majú potenciál zmeniť spôsob akým píšeme každodenný kód.

Ktorá fičúrka z PHP 8.4 je podľa teba top? Ak máš chuť pokecať, kľudne mi napíš. Za mňa sú to určite property hooks 🤘