Ho scritto getter e setter per 20 anni.

PHP 8.4 ha reso inutili molti getter e setter banali.

PHP 8.4 ha introdotto Property Hooks e Asymmetric Visibility nel novembre 2024. Due feature che la community aspettava da oltre un decennio. Questo articolo racconta cosa cambia nel modo concreto di scrivere classi PHP.

Il pattern che ho usato per vent’anni

Se hai scritto PHP per qualche anno, conosci questo pattern a memoria. Una proprieta privata, un metodo getter per leggerla, un metodo setter per modificarla. Incapsulamento corretto, validazione centralizzata, controllo degli accessi. Tutto giusto. Tutto necessario.

Il problema non era il pattern in se. Era la quantita di codice che dovevi scrivere per implementarlo, ogni volta, per ogni proprieta, in ogni classe.

class User {

    private string $name;
    private string $email;
    private int $age;

    public function getName(): string {
        return $this->name;
    }

    public function setName(string $name): void {
        $this->name = trim($name);
    }

    public function getEmail(): string {
        return $this->email;
    }

    public function setEmail(string $email): void {
        if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
            throw new InvalidArgumentException('Email non valida');
        }
        $this->email = strtolower($email);
    }

    public function getAge(): int {
        return $this->age;
    }

    public function setAge(int $age): void {
        if ($age < 0 || $age > 150) {
            throw new InvalidArgumentException('Eta non valida');
        }
        $this->age = $age;
    }

}

Una classe con tre proprieta. Quarantacinque righe di codice. Di cui trenta sono puro boilerplate che non aggiunge logica reale al progetto.

Moltiplicalo per tutte le classi del tuo dominio e capisci perche la community PHP chiedeva una soluzione da oltre dieci anni.

Property Hooks: cosa cambia in PHP 8.4

PHP 8.4 introduce i Property Hooks: la possibilita di definire logica get e set direttamente sulla dichiarazione della proprieta, senza metodi separati.

La stessa classe di prima, riscritta con PHP 8.4:

class User {

    public string $name {
        set => trim($value);
    }

    public string $email {
        set {
            if (!filter_var($value, FILTER_VALIDATE_EMAIL)) {
                throw new InvalidArgumentException('Email non valida');
            }
            $this->email = strtolower($value);
        }
    }

    public int $age {
        set {
            if ($value < 0 || $value > 150) {
                throw new InvalidArgumentException('Eta non valida');
            }
            $this->age = $value;
        }
    }
}

Da quarantacinque righe a venti. Stessa logica di validazione, stessa sicurezza, zero metodi getter e setter espliciti per i casi con logica banale.

Se ometti il parametro del set hook, PHP rende disponibile automaticamente il valore in ingresso nella variabile $value. In alternativa puoi dichiarare esplicitamente il parametro, anche con tipo e nome personalizzato.

Hook get: proprieta calcolate senza metodi extra

Il get hook e utile per proprieta calcolate al volo, senza bisogno di memorizzare il valore:

class Order {

    public float $subtotal;
    public float $taxRate;

    public float $total {
        get => $this->subtotal * (1 + $this->taxRate);
    }

}

$total non esiste come valore memorizzato. Viene calcolato ogni volta che lo leggi. Prima avresti scritto un metodo getTotal(). Ora e una proprieta come le altre.

Hook get e set insieme

Puoi definire entrambi gli hook sulla stessa proprieta:

class Temperature {

    private float $celsius;

    public float $fahrenheit {
        get => ($this->celsius * 9/5) + 32;
        set => $this->celsius = ($value - 32) * 5/9;
    }

}

Puoi leggere e scrivere in Fahrenheit. Internamente tutto e memorizzato in Celsius. La conversione e trasparente per chi usa la classe.

Asymmetric Visibility: pubblica in lettura, privata in scrittura

PHP 8.4 introduce anche Asymmetric Visibility: la possibilita di dichiarare visibilita diverse per lettura e scrittura di una proprieta.

In pratica: una proprieta che chiunque puo leggere, ma che solo la classe stessa puo modificare.

class User {

    public private(set) string $email;
    public private(set) int $loginCount = 0;
    public private(set) DateTime $createdAt;

    public function __construct(string $email) {
        $this->email = $email;
        $this->createdAt = new DateTime();
    }

    public function recordLogin(): void {
        $this->loginCount++;
    }

}

$email, $loginCount e $createdAt sono leggibili da fuori ma modificabili solo dall’interno della classe. Prima avresti usato proprieta private con getter pubblici. Ora basta una riga.

Il confronto che conta: righe di codice per stessa funzionalità

Compatibilità e migrazione

Property Hooks e Asymmetric Visibility sono disponibili da PHP 8.4.0, rilasciato il 21 novembre 2024. Non esistono polyfill: richiedono PHP 8.4 installato.

Cosa fare con il codice esistente

Non devi riscrivere nulla. Il vecchio pattern getter/setter continua a funzionare perfettamente. La migrazione ha senso quando:

• Stai creando nuove classi da zero
• Stai rifattorizzando classi esistenti per altri motivi
• Vuoi ridurre il boilerplate in classi con molte proprieta

Non ha senso migrare codice che funziona solo per il gusto di usare la nuova sintassi. Il refactoring ha un costo: fallo quando porta un beneficio reale.

Verifica la versione PHP

pc-name: php -v
-> PHP 8.4.X (CLI)... 

Se usi i framework controlla lo loro compatibilità, e se devi lavorare su progetti datati verifica se puoi aggiornare la versione del framework

Cosa cambia davvero nel modo di scrivere PHP

Property Hooks non e una feature rivoluzionaria nel senso che cambia l’architettura del tuo codice. E una feature che elimina il rumore: tutto quel codice che scrivevi per motivi tecnici, non per ragioni di dominio. Questo vale in modo netto per i getter e setter banali, quelli senza logica reale. Per i casi piu complessi, i metodi espliciti restano la scelta giusta.

Asymmetric Visibility rende esplicita un’intenzione che prima richiedeva una convenzione: questa proprieta e pubblica in lettura e privata in scrittura. Prima lo comunicavi con un commento o con la struttura del codice. Ora lo dichiari direttamente nel tipo.

Dopo vent’anni di getter e setter, mi trovo a scrivere classi piu corte, piu leggibili, con la stessa solidita di prima. Non e poco.