PHP 8.x: cosa è cambiato dal PHP 7

PHP 8.0, rilasciato ufficialmente il 26 novembre 2020, non è un semplice aggiornamento: è una nuova major version che cambia il modo di scrivere codice. È più veloce, più chiaro e più severo nel segnalare gli errori. In questa pillola vediamo, con esempi concreti, le novità che contano davvero per chi arriva da PHP 7.

PHP 8 è più veloce: il compilatore JIT

La novità più pubblicizzata di PHP 8 è il JIT (Just-In-Time): traduce in anticipo le parti di codice più usate in istruzioni che il processore esegue direttamente, senza reinterpretarle ogni volta. È come se un cuoco che, invece di rileggere la ricetta ogni volta che prepara lo stesso piatto, la impara a memoria. Dalla seconda volta in poi è molto più rapido.

Attenzione però: sul classico sito web (molta attesa di dati, pochi calcoli) il guadagno è modesto. Il JIT brilla nelle applicazioni con calcoli intensi, ma resta un passo importante per il futuro del linguaggio.

Fonte: PHP.net: PHP 8.0 Release Announcement (php.net/releases/8.0/en.php)

Scrivere meno, e più chiaro

PHP 8 introduce diverse novità di sintassi che tolgono di mezzo il codice ripetitivo:

• Argomenti con nome: puoi passare i parametri indicando il loro nome, senza dover rispettare l'ordine esatto.

// PHP 7: l'ordine conta e non è chiaro cosa significhino i valori
salvaCache('user_42', 3600, true);

// PHP 8: ogni valore ha la sua etichetta
salvaCache(chiave: 'user_42', durata: 3600, comprimi: true);

• Promozione delle proprietà nel costruttore: dichiari e assegni una proprietà in un colpo solo.

// PHP 7: il nome della proprietà ripetuto tre volte
class Punto {
    public float $x;
    public function __construct(float $x) {
        $this->x = $x;
    }
}

// PHP 8: una riga sola
class Punto {
    public function __construct(public float $x) {}
}

• match: una versione più pulita e sicura di switch. È un'espressione (restituisce un valore), non serve break e confronta in modo stretto (===).

$accesso = match ($ruolo) {
    'admin'  => 'totale',
    'editor' => 'parziale',
    default  => 'nessuno',
};

• Operatore nullsafe (?->): attraversa una catena di oggetti e si ferma da sola se un anello è null, senza generare errori.

// PHP 7: una catena di controlli
$citta = null;
if ($utente !== null && $utente->indirizzo !== null) {
    $citta = $utente->indirizzo->citta;
}

// PHP 8: una riga, si ferma da sola se qualcosa è null
$citta = $utente?->indirizzo?->citta;

Fonte: PHP.net: Manuale, sezioni «Funzioni», «Strutture di controllo: match» e «Operatori»

PHP 8 è più rigoroso (e questo ti salva da bug)

PHP 7 era a volte troppo «accomodante» quando confrontava tipi diversi, e così nascondeva errori. Il caso più famoso è il confronto tra un numero e una stringa di testo: PHP 8 lo ha reso finalmente sensato.

Nella stessa direzione vanno i tipi di unione (union types), che permettono di dichiarare apertamente che un valore può essere, ad esempio, un numero oppure un testo:

function leggiId(int|string $id): string { /* ... */ }

Fonte: PHP.net: RFC «Saner numeric strings» e Manuale «Type declarations»

Non solo 8.0: le tappe successive (8.1 → 8.4)

PHP non si è fermato alla 8.0: ogni anno, a novembre, arriva una nuova versione minore. Le due novità più utili da conoscere subito:

• Enum (da PHP 8.1): un insieme fisso di valori ammessi, definito una volta per tutte.

// PHP 7: stringhe «magiche», un typo passa inosservato
if ($ordine->stato === 'pagato') { /* e se scrivo 'paggato'? */ }

// PHP 8.1: valori fissi e controllati dal linguaggio
enum StatoOrdine {
    case InAttesa;
    case Pagato;
    case Spedito;
}
if ($ordine->stato === StatoOrdine::Pagato) { /* un typo = errore subito */ }

• Proprietà readonly (da PHP 8.1): un valore che si scrive una sola volta e poi non cambia più.

class Utente {
    public function __construct(public readonly string $email) {}
}
$u = new Utente('mario@rossi.it');
$u->email = 'altro@rossi.it';  // Errore: proprietà readonly

In sintesi, le altre tappe: classi readonly e tipi più flessibili (8.2), costanti di classe tipizzate e json_validate() (8.3), property hooks e visibilità asimmetrica (8.4).

Fonte: PHP.net: Manuale «Enumerations» e «Readonly properties»; note di migrazione per versione

Riepilogo: PHP 7 vs PHP 8

Conclusione

Passare da PHP 7 a PHP 8 significa codice più veloce da eseguire, più corto da scrivere e più difficile da sbagliare. Se lavori ancora su PHP 7, tieni presente che l'intera serie 7.x ha raggiunto la fine del supporto ufficiale: aggiornare non è solo una questione di comodità, ma anche di sicurezza. La guida ufficiale alla migrazione su php.net elenca passo passo le poche incompatibilità da controllare.

Riferimenti ufficiali

• PHP 8.0: Annuncio di rilascio: php.net/releases/8.0/en.php
• Guida alla migrazione da PHP 7.4 a 8.0: php.net/manual/en/migration80.php
• Enumerazioni (Enum): php.net/manual/en/language.enumerations.php
• Espressione match: php.net/manual/en/control-structures.match.php
• Versioni supportate: php.net/supported-versions.php