Comprendere le Proprietà Statiche nella OOP PHP

Una proprietà statica appartiene alla classe stessa piuttosto che a un singolo oggetto creato da essa. Mentre una proprietà ordinaria (di istanza) ha la propria copia in ogni oggetto, una proprietà statica esiste esattamente una volta ed è condivisa da tutte le istanze — modificarla in un posto e tutte le istanze vedranno il nuovo valore. Questa pagina spiega come dichiarare proprietà statiche, come leggerle e scriverle, come differiscono self, static e parent, come si comportano con l'ereditarietà e le insidie da tenere d'occhio.

Se sei nuovo alle classi PHP, inizia prima con Classi e Oggetti PHP.

Cos'è una proprietà statica?

Si dichiara una proprietà statica con la parola chiave static, combinata con un modificatore di visibilità (public, protected o private):

<?php

class User {
    public static int $count = 0;

    public function __construct() {
        self::$count++;
    }
}

new User();
new User();
new User();

echo User::$count; // 3

Tre aspetti rendono una proprietà statica diversa da una ordinaria:

• Accessibile tramite la classe, non un oggetto. Si scrive User::$count con l'operatore di risoluzione dell'ambito ::, non $user->count. Tentare di leggere una proprietà statica attraverso l'operatore freccia ($user->count) non funziona e genera un avviso.
• Condivisa, non copiata. Ogni new User() incrementa lo stesso $count. Esiste una sola copia in memoria per l'intera classe.
• Referenziata come self::$count all'interno della classe. All'interno di un metodo, si accede alla proprietà tramite self::, static:: o parent:: — mai $this.

Leggere e scrivere una proprietà statica

Dall'interno della classe, si usa self::$property. Dall'esterno, si usa ClassName::$property. Poiché esiste una sola copia, una scrittura da qualsiasi contesto è visibile ovunque:

<?php

class Counter {
    public static int $value = 0;

    public static function increment(): void {
        self::$value++;
    }
}

Counter::increment();
Counter::increment();
Counter::$value += 10; // also writable directly from outside

echo Counter::$value; // 12

Una proprietà statica può avere un valore predefinito, ma quel valore predefinito deve essere un'espressione costante (un letterale, una costante o una semplice espressione aritmetica const) — non può essere il risultato di una chiamata a funzione o di un oggetto new.

self:: vs static:: (late static binding)

All'interno di un metodo è possibile accedere a una proprietà statica con self:: o static::. Differiscono quando è coinvolta l'ereditarietà:

• self:: viene risolto a tempo di compilazione e punta sempre alla classe dove il codice è scritto.
• static:: usa il late static binding — punta alla classe su cui il metodo è stato chiamato a runtime.

<?php

class Base {
    public static string $label = "Base";

    public static function whoAmISelf(): string {
        return self::$label;   // bound to Base
    }

    public static function whoAmIStatic(): string {
        return static::$label; // bound to the calling class
    }
}

class Child extends Base {
    public static string $label = "Child";
}

echo Child::whoAmISelf();  // Base
echo "\n";
echo Child::whoAmIStatic(); // Child

Usa static:: quando vuoi che le sottoclassi possano sovrascrivere il valore; usa self:: quando il valore deve rimanere legato alla classe che lo dichiara. Vedi Metodi Statici PHP per ulteriori informazioni sulla chiamata di membri statici.

Quando dovresti usare le proprietà statiche?

Le proprietà statiche sono utili quando un dato di stato deve essere condiviso tra tutte le istanze di una classe:

• Conteggio delle istanze — l'esempio User::$count sopra traccia quanti oggetti esistono.
• Caching / registri — memorizza una tabella di lookup o una singola risorsa condivisa (ad es. un handle di connessione al database) in modo che venga creata una volta sola e riutilizzata.
• Configurazione o flag — un valore predefinito che si applica all'intera classe, come un User::$defaultRole globale.
• Il pattern Singleton — una proprietà statica privata contiene la singola istanza restituita da getInstance().

Se il valore non deve mai cambiare dopo la dichiarazione, preferisci una costante di classe (const) — esprime meglio l'intenzione e non può essere riassegnata.

Insidie comuni

• Le proprietà statiche non sono costanti. Sono mutabili; qualsiasi codice con accesso può riassegnarle. Usa const per valori che non devono cambiare.
• Lo stato condiviso è un'arma a doppio taglio. Poiché tutte le istanze condividono il valore, una modifica in un oggetto si riflette ovunque — pratico per i contatori, pericoloso se ti aspettavi dati per oggetto.
• Nessun $this in un contesto statico. I metodi statici non hanno $this, quindi una proprietà statica deve essere raggiunta con self::, static:: o parent::.
• L'ereditarietà condivide lo storage del genitore a meno che non venga ridichiarata. Una sottoclasse che non ridichiari una proprietà statica condivide la copia unica del genitore; ridichiarla (come fa Child sopra) fornisce alla sottoclasse la propria copia.

Conclusione

Le proprietà statiche permettono a una classe di mantenere uno stato condiviso da tutte le sue istanze, accessibile tramite il nome della classe con l'operatore :: e tramite self::/static:: all'interno della classe. Sono ideali per contatori, cache, registri e singleton. Usa una const di classe quando il valore deve rimanere fisso, e ricorda che static:: abilita il late static binding in modo che le sottoclassi possano sovrascrivere il valore. Poi, esplora Metodi Statici PHP e Ereditarietà PHP per vedere come questi elementi si incastrano.

Pratica