PHP 8.4 – funktioner, förbättringar och nyheter

PHP 8.4 är här! Det är en gedigen uppgradering, med flera nya funktioner. Vi har valt ut att lyfta 5 nyheter som vi gläds lite extra åt.

PHP 8.4, 1280x720, 16x9 ratio3
  1. Property Hooks
  2. Fyra nya Array-funktioner
  3. Support för HTML5
  4. Implicit Nullable Types
  5. Förändringar i JIT

PHP 8.4 – här är 5 utvalda nyheter 

Örnen, eller närmare bestämt PHP 8.4, har landat – och det är en tämligen gedigen uppgradering! Med sig har den en hel drös med nya funktioner som kommer glädja dig och ditt kodande. 

Vi pratar gärna om varför det är viktigt att hänga med i uppdateringar som sker, inte minst av säkerhetsmässiga skäl. Men det finns såklart fler orsaker till att vara på alerten. Jaså, vilka skulle de anledningarna vara, undrar du?  

Tja, vi kan väl ge dig ett litet axplock – eller 5 anledningar, för att vara exakt. Det ska nog finnas flera spännande uppdateringar och nya funktioner från PHP 8.4 som är orsak nog att implementera den senaste versionen till dina applikationer. 

Och innan vi kommer till sak vill vi bara ödmjukt påminna och fötydliga att vi inte byter PHP-version automatiskt åt dig. När du gör det bestämmer du helt själv! Om du är osäker kan du läsa mer här om hur du hanterar din PHP-version och vilka versioner vi uppdaterar med säkerhetsfixar innan de nått end-of-life.

Skriv renare kod med Property Hooks 

Kort och gott tillåts du nu bättre styra hur dina attribut ska sättas och hämtas. 

Property hooks är ett sätt för att fånga upp read-and-write för ett attribut och minskar därmed behovet av vissa boilerplates. Glöm “getters” och “setters” – anropa attributet direkt istället! 

Exempel (från php.net): 

<?php
class Example
{
    private bool $modified = false;

    public string $foo = 'default value' {
        get {
            if ($this->modified) {
                return $this->foo . ' (modified)';
            }
            return $this->foo;
        }
        set(string $value) {
            $this->foo = strtolower($value);
            $this->modified = true;
        }
    }
}

$example = new Example();
$example->foo = 'changed';
print $example->foo;
?>

Flera nya Array Find-funktioner  

Möjligheten att inspektera har förenklats med fyra nya array-funktioner, som tillsammans underlättar det att söka, hitta och verifiera element: 

  • array_find – hitta enkelt värdet tillhörande det första element som matchar ditt villkor 
  • array_find_key – hittar enkelt nyckeln tillhörande det första element som matchar ditt villkor 
  • array_any – kontrollera om callbacken matchar något element överhuvudtaget
  • array_all – kontrollera om callbacken matchar alla element  

Exempel på array_find (från php.watch):

function is_even(int $value): bool {
    return $value % 2 === 0;
}

array_find([1, 2, 3, 4, 5], 'is_even');
// 2

Och ett på array_find_key (från php.watch):

function is_even(int $value): bool {
    return $value % 2 === 0;
}

array_find_key(['foo' => 1, 'bar' => 2, 'baz' => 3], 'is_even');
// "bar"

Och ett sista exempel på array_any och array_all (från stitcher.io): 

$numbers = [1, 2, 3, 4, 5, 6];

// True: at least one element is dividable by 2
array_any(
    array: $numbers,
    callback: fn (int $number) => $number % 2 === 0
);

// False: not all elements are dividable by 2
array_all(
    array: $numbers,
    callback: fn (int $number) => $number % 2 === 0
);

// True: all elements are smaller than 10
array_all(
    array: $numbers,
    callback: fn (int $number) => $number < 10
);

Support för HTML5

Det tog sin tid, men den som väntar på något gott… PHP 8.4 ger nu support för HTML5 genom att uppdatera sitt DOM-API och introducera en ny klass, \Dom\HTMLDocument. 

Det betyder att du kan söka igenom (parse) dina HTML-filer med större precision och i slutändan få ut mer information.  

Implicit Nullable Types

Det är slut på gissningslekar. 

Redan från PHP 7.1 har “nullable-types” kunnat deklareras som explicita med ?TYPE. Förändringen i PHP 8.4 handlar dock om ”implicit nullable types”. Tidigare kunde en parameter ges ett standardvärde null utan att null uttryckligen inkluderades i typdeklarationen (string), exempelvis: 

function test(string $test = null) {}

test('PHP'); // Allowed
test(null); // Allowed

Här implicit tillåts null trots att det inte nämns som en del av typdeklarationen (string). I PHP 8.4 markeras detta som deprecated, och man måste explicit ange null i typen: 

function test(?string $test = null) {}

 test('PHP'); // Allowed
 test(null); // Allowed

Den stora förändringen är alltså att PHP inte längre accepterar ”implicit nullable types” utan att generera en varning. Du behöver uttryckligen inkludera null som en del av typen för att följa de nya riktlinjerna.

Fördelen är att detta gör din kod mer läsbar och minskar risken för buggar. 

Förändringar i JIT 

En sista uppdatering vi vill lyfta är de ändringar som gjorts för JIT. De har genomfört generella optimeringar och justeringar, vilket kommer ge snabbare exekvering och även minska minnesanvändningen i vissa lägen.  

En större förändring som implementerats gäller hur JIT aktiveras.  

Det som innan krävde att du ställde in opcache.jit_buffer_size till 0 för att avaktivera, kan nu styras såhär: 

opcache.jit=tracing
opcache.jit=disable

opcache.jit_buffer_size=0
opcache.jit_buffer_size=64M

Detta påverkar bara dig som användare om du specificerat en opcache.jit_buffer_size men inte en opcache.jit. Om det gäller dig, behöver du lägga till opcache.jit=tracing för att aktivera JIT igen.  

Ja, sammantaget kan vi väl konstatera att PHP 8.4 är en gedigen uppdatering som gör livet lättare för alla PHP-utvecklare. Den erbjuder flera nya funktioner, förbättrad säkerhet och en mer intuitiv syntax. Ett steg i helt rätt riktning och har något som alla PHP-entusiaster kan glädjas åt.  

Nyfiken på det senaste från Oderland?