È finalmente arrivato l’autunno, e con lui il tempo di una nuova versione di PHP, il linguaggio di scripting lato server che alimenta il nostro CMS preferito, WordPress. In vista del lancio della versione 8.4, previsto per il 21 novembre, gli sviluppatori di PHP hanno presentato numerose prime versioni della nuova base di codice, tra cui una manciata di release candidate dopo il blocco delle feature di agosto.

Oltre alle nuove funzionalità, ai miglioramenti e alle deprecazioni che sappiamo arrivare in questo periodo dell’anno, il 2024 ha visto delle modifiche al ciclo di rilascio di PHP, con la fine dei rilasci di sicurezza per tutte le versioni attualmente supportate sincronizzata con la fine dell’anno invece che con il suo compleanno della sua disponibilità generale (GA).

Inoltre, il supporto è stato esteso di un anno, il che significa che potrete utilizzare PHP 8.4 in tutta sicurezza fino al 2028 (con due anni di correzioni di sicurezza e bug e due anni di sole correzioni di sicurezza).

Anche se passerete parecchio tempo con PHP 8.4, probabilmente volete scoprire subito le novità di questa versione. Perciò, iniziamo.

Nuove funzionalità e miglioramenti in PHP 8.4

Le nuove funzionalità incluse nel rilascio di PHP 8.3 lo scorso anno sembreranno di poco conto se paragonate ad alcune delle aggiunte presenti nella versione 8.4:

Hook delle proprietà

Gli hook delle proprietà offrono un approccio completamente nuovo alla gestione dei “getter” e dei “setter” nella programmazione orientata agli oggetti di PHP (object-oriented programming, OOP), consentendo di semplificare la struttura dei propri file di classe.

Come esempio di ciò che gli hook delle proprietà possono sostituire, la semplice classe qui sotto include le proprietà $size e $flavor. Esse hanno visibilità private per proteggerle dall’accesso diretto all’esterno dell’oggetto risultante. Ecco perché i metodi pubblici getter e setter mediano l’accesso alle proprietà:

class Coffee
{
    private string $size;
    private string $flavor;
    public function __construct(string $size, string $flavor) {
        $this->size   = $size;
        $this->flavor = $flavor;
    }

    // "Setting" coffee size and flavor
    public function setSize(string $size): void {
        $this->size = $size;
    }
    public function setFlavor(string $flavor): void {
        $this->flavor = $flavor;
    }

    // "Getting" coffee size and flavor
    public function getSize(): string {
        return $this->size;
    }
    public function getFlavor(): string {
        return $this->flavor;
    }
} // End of class

// Make some coffee
$coffee = new Coffee('Small', 'Pumpkin Spice');
print $coffee->getSize() . ' ' . $coffee->getFlavor(); // Prints "Small Pumpkin Spice"

// Change order
$coffee->setSize('Grande');
$coffee->setFlavor('Mocha');
print $coffee->getSize() . ' ' . $coffee->getFlavor(); // Prints "Grande Mocha"

Oppure, forse la vostra classe ha molte proprietà e, invece di scrivere molti metodi getter e setter, potete utilizzare i metodi magici _get e _set di PHP. Potreste anche risolvere il tutto con una dichiarazione switch un po’ disordinata, come questo estratto qui sotto.

// __set magic method example
public function __set(string $key, $value): void 
    switch ($key) {
        case 'size':
            $this->size = $value;
            break;
        case 'flavor':
            $this->flavor = $value;
            break;
        default:
            throw new InvalidArgumentException('Invalid input');
        }
}

// Later, we can change the coffee order like this:
$coffee->size = 'Grande';
$coffee->flavor = 'Mocha';

Qualunque sia l’approccio scelto, più proprietà avete nella vostra classe, più il codice utilizzato per manipolarle sarà lontano dalle loro definizioni all’inizio del file di classe. Inoltre, alcune implementazioni dei metodi magici _get e _set possono fornire inaspettatamente l’accesso a proprietà private o protette del vostro oggetto che non avevate intenzione di esporre.

La nuova funzione di hook delle proprietà raggruppa le funzionalità di getter e setter con le proprietà stesse. Nell’esempio di hook delle proprietà riportato di seguito, noterete che le proprietà $size e $flavor della classe Coffee sono ora pubbliche. Ma abbiamo anche aggiunto una convalida di base agli hook set, differenziandoli dalle assegnazioni dirette.

// Property definitions at the top of our Coffee class
class Coffee
{
    public string $flavor {
        set(string $value) {
            if (strlen($value) > 16) throw new InvalidArgumentException('Input is too long');
                $this->flavor = $value;
        }
    }

    public string $size {
        set(string $value) {
            if (! in_array($value, array(‘Small’, ‘Grande’))) throw new InvalidArgumentException('Not a valid size');
                $this->size = $value;
        }
    }

    // Rest of the Coffee class
}

// Define a coffee
$coffee = new Coffee();
$coffee->size = 'Grande';
$coffee->flavor = 'Pumpkin spice';

Allo stesso modo, come potete vedere qui sotto, un hook get può racchiudere delle funzionalità in quello che sembra essere un normale riferimento a una proprietà dell’oggetto.

// Simplified Coffee class
class Coffee
{
    public string $flavor {
        get { 
            return $this->flavor . ' Spice';
       }
    }
}

// Create a flavor 
$coffee = new Coffee();
$coffee->flavor = 'Pumpkin'; // Stores the value "Pumpkin"
print $coffee->flavor;       // Prints "Pumpkin Spice"

A differenza dei metodi magici di PHP, gli hook delle proprietà possono essere utilizzati nelle interfacce e nelle classi astratte. Un esempio di interfaccia:

interface Coffee
{
    public string $size { get; set; }
    public string $flavor { get; set; }
}

Visibilità asimmetrica

I metodi getter e setter visibili pubblicamente che abbiamo visto in precedenza rappresentano l’approccio tradizionale all’accesso alle proprietà private e protette all’interno delle classi.

Una caratteristica interessante di PHP 8.4 è la possibilità per una proprietà di avere diversi livelli di visibilità a seconda del contesto in cui vi si accede. Quindi, una proprietà potrebbe essere pubblica quando viene letta, ma privata o protetta quando viene impostata.

Guardate qui:

class Coffee
{
    public private(set) string $flavor = 'Pumpkin Spice';
}

$coffee = new Coffee();
print $coffee->flavor;     // Prints "Pumpkin Spice"
$coffee->flavor = 'Mocha';  // Error (visibility)

Qui sopra, la proprietà $flavor della classe è pubblica tranne che in un contesto di impostazione. È già abbastanza semplice, ma la visibilità asimmetrica ha anche una scorciatoia:

class Coffee
{
    // public is assumed when the context is not setting
    private(set) string $flavor = 'Pumpkin Spice';
}

È possibile usare gli hook delle proprietà e la visibilità asimmetrica in combinazione per ottenere un’enorme flessibilità nel lavorare con le proprietà degli oggetti di varia visibilità.

Concatenare new senza parentesi

Parlando di abbreviazioni, la chiamata a new e il concatenamento di metodi richiedeva l’inserimento dell’invocazione tra parentesi, come in questo caso:

$coffee = (new Coffee())->getFlavor()->getSize();

PHP 8.4 consente questo:

$coffee = new Coffee()->getFlavor()->getSize();

Può sembrare una modifica di poco conto, ma l’eliminazione di due sole parentesi rende molto più semplice la lettura e il debug.

Nuove funzioni per trovare gli elementi di un array

Per quanto riguarda il reparto “Ma perché, non potevamo già farlo?”, PHP 8.4 introduce la funzione array_find(), che può cercare gli elementi dell’array per i membri che corrispondono alle condizioni espresse in una funzione di callback. La funzione restituisce il valore del primo elemento che corrisponde al test del callback.

La nuova versione include altre tre funzioni correlate:

  • array_find_key(): come array_find(), ma il valore restituito è la chiave dell’elemento corrispondente invece del valore dell’elemento stesso.
  • array_all(): restituisce true se ogni elemento dell’array testato corrisponde al test del callback.
  • array_any(): restituisce true se almeno uno degli elementi dell’array corrisponde al test del callback.

Le ultime due funzioni restituiscono indicatori booleani invece di chiavi o contenuti dell’array.

Ecco alcuni rapidi esempi:

$array = [
    'a' => 'Mocha',
    'b' => 'Caramel',
    'c' => 'Maple',
    'd' => 'Pumpkin'
   ];

// Find the first flavor name that is 5 characters long
var_dump(array_find($array, function (string $value) {
    return strlen($value) == 5;
})); // Returns “Mocha,” even though “Maple” is the same length 

// Find the array key for the first flavor with a name longer than 5 characters.
var_dump(array_find_key($array, function (string $value) {
    return strlen($value) > 5;
})); // Returns “b”

// Check to see if any flavor name is less than 5 characters long
var_dump(array_any($array, function (string $value) {
    return strlen($value) < 5;
})); // Returns false

// Check to see if all flavor names are shorter than 8 characters
var_dump(array_all($array, function (string $value) {
    return strlen($value) < 8;
})); // Returns true

Parsing di HTML5

L’HTM5 è lo standard definitivo per la struttura delle pagine web moderne, ma la tecnologia di parsing del Document Object Model (DOM) di PHP si era fermata all’HTML 4.01.

Piuttosto che eseguire l’upgrade della classe DOMDocument esistente che funziona con i vecchi standard HTML, PHP 8.4 è dotato di una nuova classe DomHTMLDocument pronta per HTM5.

Potete importare il contenuto di una pagina HTML5 in questo modo:

$document = DomHTMLDocument::createFromString($html)

Oltre al costruttore createFromString($html) di cui sopra, la classe supporta anche createFromFile($path) e createEmpty()

Il nuovo parser riconosce i tag HTML5 semantici come main, article e section che ormai sono familiari alla maggior parte di noi.

Funzioni di trim multibyte

Un’altra aggiunta di PHP 8.4 che aspettavamo da tempo è il supporto del multibyte nelle funzioni di trim:

  • mb_trim()
  • mb_ltrim()
  • mb_rtrim()

Come la storica funzione PHP trim(), mb_trim rimuove gli spazi bianchi e alcuni caratteri speciali, come gli avanzamenti di riga, da entrambe le estremità di una stringa che può contenere caratteri multibyte. Le altre funzioni tagliano l’estremità sinistra o destra di una stringa.

Deprecazioni in PHP 8.4

Ogni versione di PHP porta con sé una lista di caratteristiche e funzioni (alcune piuttosto oscure) che vengono segnalate per l’eventuale rimozione dalla piattaforma. Una deprecazione di alto profilo in PHP 8.4 è il tracciamento delle sessioni senza cookie.

Deprecazione delle sessioni GET/POST

Sebbene i cookie siano generalmente il metodo preferito per tracciare le sessioni degli utenti, PHP ha supportato il fissaggio dei dati dell’ID di sessione nei parametri GET/POST. Per abilitare il tracciamento delle sessioni tramite parametri negli URL, l’impostazione PHP session.use_only_cookies è disabilitata e l’impostazione session.use_trans_sid può essere abilitata.

Con PHP 8.4, uno di questi stati per le impostazioni attiverà un avviso di deprecazione che potrebbe apparire nei log del vostro sito web. Quando verrà rilasciato PHP 9, queste impostazioni non saranno più disponibili.

Altre deprecazioni (e rimozioni) in PHP 8.4

Di seguito è riportato un elenco di funzionalità che il team di PHP 8.4 ha deciso di deprecare. (Alcune includono link a ulteriori informazioni sulle funzionalità…),

  • Deprecate formalmente le proprietà DOMDocument e DOMEntity.
  • Rimosso DOMImplementation::getFeature($feature, $version).
  • Deprecata la costante DOM_PHP_ERR.
  • Deprecato il tag “S” in unserialize().
  • Deprecate session.sid_length e session.sid_bits_per_character.
  • Deprecato SplFixedArray::__wakeup().
  • Deprecati xml_set_object() e xml_set_*_handler() con nomi di metodi stringa.
  • Deprecato il passaggio di null e false a dba_key_split().
  • Deprecato il passaggio di tipi di dati errati per le opzioni alle funzioni ext/hash.
  • Deprecate le costanti SUNFUNCS_RET_STRING, SUNFUNCS_RET_DOUBLE, SUNFUNCS_RET_TIMESTAMP.
  • Deprecato il meccanismo di escape proprietario di CSV.
  • Deprecata la costante E_STRICT.
  • Deprecato strtok().
  • Deprecata la restituzione di valori non stringa da un gestore di output utente.
  • Deprecata la produzione di output in un gestore di output utente.
  • Deprecato file_put_contents() con $data come array.
  • Deprecati mysqli_ping() e mysqli::ping()
  • Deprecato mysqli_refresh().
  • Deprecato mysqli_kill().
  • Deprecato il secondo parametro di mysqli_store_result().
  • Deprecato lcg_value().
  • Deprecato uniqid().
  • Deprecati md5(), sha1(), md5_file(), e sha1_file().
  • Deprecato il passaggio di E_USER_ERROR a trigger_error().
  • Deprecato l’uso di un singolo trattino basso (“_”) come nome di classe.
  • Deprecata la costante SOAP_FUNCTIONS_ALL e il suo passaggio a SoapServer::addFunction().

Riepilogo

PHP 8.4 presenta alcuni cambiamenti interessanti. Non vediamo l’ora di mettere questa versione sui nostri server per il nostro benchmarking annuale di PHP, ovvero il nostro test con vari sistemi di gestione dei contenuti basati su PHP.

Siamo anche interessati a vedere quando gli sviluppatori inizieranno a incorporare alcune delle nuove funzionalità di PHP 8.4 nei loro progetti, in particolare gli hook delle proprietà.

Quali sono le vostre caratteristiche preferite di PHP 8.4? Condividete i vostri pensieri con la nostra community nei commenti!

Steve Bonisteel Kinsta

Steve Bonisteel è un Technical Editor di Kinsta che ha iniziato la sua carriera di scrittore come giornalista della carta stampata, inseguendo ambulanze e camion dei pompieri. Dalla fine degli anni '90 si occupa di tecnologia legata a Internet.