PHP 8.4: Property Hooks, Asymmetric Visibility e Lazy Objects — guida pratica

Hai mai scritto decine di getter e setter manuali in una classe PHP? O dovuto inizializzare un oggetto pesante a ogni richiesta anche quando non serviva? PHP 8.4 risolve esattamente questi problemi con tre novità che cambiano il modo di scrivere codice pulito e performante: Property Hooks, Asymmetric Visibility e Lazy Objects.

Noi, di Meteora Web, lavoriamo con PHP da anni. Su WordPress, Laravel, piattaforme custom. E sappiamo quanto tempo si perde a scrivere boilerplate o a ottimizzare lazy loading a mano. PHP 8.4 mette queste funzionalità direttamente nel linguaggio. Vediamo come funzionano e, soprattutto, quando usarle.

Property Hooks: addio a getter e setter manuali

Se hai mai lavorato con classi che espongono proprietà pubbliche ma devi applicare logica di validazione o trasformazione, sai che la soluzione classica era scrivere metodi get e set. Con PHP 8.4 puoi definire direttamente hooks sulle proprietà, esattamente come in C# o Kotlin.

Prima: il vecchio modo

class User {
    private string $name;

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

    public function setName(string $value): void {
        if (strlen($value) < 2) {
            throw new \InvalidArgumentException('Nome troppo corto');
        }
        $this->name = trim($value);
    }
}

Dopo: Property Hooks

class User {
    public string $name {
        set => trim($value);
        get => ucfirst($this->name);
    }

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

Il codice è più compatto, la logica è associata direttamente alla proprietà. Niente più dispersione tra metodi. Unico avvertimento: gli hooks non possono essere usati su proprietà statiche o non tipizzate. E attenzione all'ereditarietà: gli hooks possono essere sovrascritti, ma con regole precise (la proprietà deve mantenere lo stesso tipo).

Cosa fare subito

Prendi una delle tue classi più usate (ad esempio un modello di Laravel o una DTO) e prova a sostituire i getter classici con Property Hooks. Scriverai meno codice e la logica sarà più leggibile.

Asymmetric Visibility: proprietà pubbliche in lettura, private in scrittura

Quante volte hai voluto una proprietà leggibile da fuori ma scrivibile solo dall'interno della classe? Prima dovevi usare metodi getter e setter privati. Con PHP 8.4 puoi dichiarare due livelli di visibilità sulla stessa proprietà.

class Product {
    public private(set) string $sku;

    public function __construct(string $sku) {
        $this->sku = $sku; // scrittura consentita solo qui
    }
}

$product = new Product('ABC-123');
echo $product->sku; // OK
$product->sku = 'XYZ'; // Errore: accesso in scrittura privato

Puoi usare public protected(set) o protected private(set) per vari livelli. È una feature che rende finalmente esplicite le intenzioni di design della classe, senza ricorrere a pattern difensivi.

Quando usarla

• ID immutabili dopo la creazione (es. UUID di un'entità)
• Valori calcolati che devono essere letti ma non modificati dall'esterno
• Proprietà di configurazione che vuoi esporre in sola lettura

Lazy Objects: oggetti pesanti solo quando servono

Il lazy loading non è una novità in PHP, ma fino a PHP 8.4 dovevi implementarlo manualmente o con librerie come Proxy Manager. Ora il linguaggio stesso fornisce Lazy Objects attraverso la classe \LazyGhostTrait o la funzione \lazy_object.

Il problema concreto

Immagina un oggetto che carica dati da un database o da un'API al momento della costruzione. Se non ti serve sempre, stai sprecando risorse. Con Lazy Objects l'istanza viene creata solo al primo accesso a una proprietà o metodo.

class HeavyService {
    public function __construct() {
        // Simula caricamento pesante
        file_get_contents('https://api.example.com/large-data');
    }

    public function doWork(): string {
        return 'Done';
    }
}

// Crea un Lazy Ghost senza chiamare il costruttore
$lazyService = \lazy_object(HeavyService::class);

// Il costruttore viene eseguito solo qui
$result = $lazyService->doWork();

Puoi anche definire un initializer personalizzato per non eseguire il costruttore standard:

$lazy = \lazy_object(HeavyService::class, function() {
    // Inizializzazione personalizzata
    $instance = new HeavyService('cache_value');
    return $instance;
});

Ghost vs Virtual Proxy

PHP 8.4 offre due modalità: Ghost (l'oggetto sembra normale ma è vuoto finché non viene toccato) e Virtual Proxy (un wrapper che rimanda a un oggetto reale quando serve). Per la maggior parte dei casi, Ghost è più semplice e trasparente.

Cosa fare subito

Identifica un servizio nella tua applicazione che viene istanziato spesso ma usato raramente (es. un client API per un endpoint secondario). Avvolgilo in un Lazy Object e misura la riduzione del tempo di bootstrap.

Considerazioni pratiche: quando non usarle

Le novità di PHP 8.4 non sono bacchette magiche. Property Hooks possono rendere il codice meno trasparente se abusati — meglio usarli solo dove c'è reale logica di validazione o trasformazione. Asymmetric Visibility è fantastico per DTO e Value Object, ma in classi con troppe proprietà può appesantire la lettura. Lazy Objects ha senso solo per oggetti veramente costosi da creare; non applicarlo a qualsiasi cosa.

Noi, di Meteora Web, abbiamo iniziato a introdurle gradualmente nei nostri progetti Laravel. Il consiglio è: aggiorna a PHP 8.4, testa in un ambiente di staging e inizia da una classe piccola. Il rischio di regressioni è bassissimo se il codice è già ben tipizzato.

In sintesi — cosa fare adesso

1. Aggiorna PHP almeno alla 8.4 sul tuo ambiente di sviluppo (usa php.net per le istruzioni).
2. Sostituisci un classico getter/setter con Property Hooks in una classe di dominio.
3. Rendi immutabile una proprietà usando Asymmetric Visibility (public private(set)).
4. Applica Lazy Object a un servizio heavy che carichi dati esterni.
5. Monitora i miglioramenti di performance e leggibilità con gli strumenti di profiling che già usi.

PHP 8.4 non è solo un aggiornamento minore: queste tre feature cambiano il modo di progettare le classi. Sfruttale bene e il tuo codice sarà più pulito, sicuro e performante.