static in PHP: metodi e proprietà statici, self vs static

Un metodo o una proprietà static appartiene alla classe stessa invece che a un oggetto. Chiami un metodo statico con ClassName::method() e leggi una proprietà statica con ClassName::$property, senza creare prima un oggetto. Dentro la classe, self:: si riferisce agli stessi membri.

<?php
class Temperature
{
    public static int $conversions = 0;

    public static function toFahrenheit(float $c): float
    {
        self::$conversions++;
        return $c * 9 / 5 + 32;
    }
}

echo Temperature::toFahrenheit(20), "\n";
echo Temperature::toFahrenheit(37.5), "\n";
echo 'Conversions so far: ', Temperature::$conversions, "\n";

Non c'è nessun new Temperature(). I membri statici sono utili per le funzioni di supporto che non hanno bisogno dello stato di un oggetto (conversioni, factory, validazione) e per i dati che appartengono alla classe nel suo insieme, come un contatore.

Le proprietà statiche sono condivise da tutti gli oggetti

Una proprietà normale ha un valore per oggetto. Una proprietà statica ha un valore per l'intera classe, quindi ogni oggetto vede lo stesso. Qui ogni nuovo User incrementa un contatore condiviso e riceve l'ID successivo:

<?php
class User
{
    private static int $nextId = 1;
    public readonly int $id;

    public function __construct(public string $name)
    {
        $this->id = self::$nextId++;
    }

    public static function created(): int
    {
        return self::$nextId - 1;
    }
}

$a = new User('Ada');
$b = new User('Grace');
$c = new User('Linus');

echo "{$a->name} #{$a->id}, {$b->name} #{$b->id}, {$c->name} #{$c->id}\n";
echo User::created(), " users created\n";

Nota il $ in self::$nextId: le proprietà statiche lo mantengono dopo ::, mentre le costanti (self::MAX) no. Una proprietà statica vive solo per una richiesta PHP. Su un sito web tipico (PHP-FPM o Apache) riparte da capo a ogni caricamento di pagina, quindi non è il posto dove salvare dati tra un visitatore e l'altro.

I metodi statici non hanno $this

Un metodo statico viene eseguito senza un oggetto, quindi $this al suo interno non esiste. Un metodo statico può chiamare altri metodi statici con self::, ma non può leggere le proprietà normali. Anche chiamare staticamente un metodo normale fallisce:

<?php
class Slug
{
    private string $separator = '-';

    public static function make(string $text): string
    {
        $text = strtolower(trim($text));
        return trim(preg_replace('/[^a-z0-9]+/', '-', $text), '-');
    }

    public function withSeparator(string $text): string
    {
        return str_replace('-', $this->separator, self::make($text));
    }
}

echo Slug::make('  Hello, Static World! '), "\n";
echo (new Slug())->withSeparator('Objects can call static methods'), "\n";

try {
    echo Slug::withSeparator('no object here');
} catch (Error $e) {
    echo get_class($e), ': ', $e->getMessage(), "\n";
}

La direzione opposta va bene: un metodo normale può chiamare quelli statici, come fa withSeparator() con self::make().

self vs static: late static binding

self:: punta alla classe in cui il codice è scritto. static:: punta alla classe su cui il metodo è stato chiamato a runtime. La differenza emerge solo con l'ereditarietà, e conta soprattutto per i metodi factory:

<?php
class Model
{
    public static function createWithSelf(): Model
    {
        return new self();
    }

    public static function createWithStatic(): static
    {
        return new static();
    }

    public static function table(): string
    {
        return strtolower(static::class) . 's';
    }

    public static function tableWithSelf(): string
    {
        return strtolower(self::class) . 's';
    }
}

class Post extends Model {}
class Comment extends Model {}

echo get_class(Post::createWithSelf()), "\n";    // Model
echo get_class(Post::createWithStatic()), "\n";  // Post
echo Post::table(), ', ', Comment::table(), "\n";
echo Post::tableWithSelf(), "\n";

Post::createWithSelf() restituisce un Model, che non è quasi mai ciò che voleva chi chiama. static si risolve in Post perché è la classe indicata nella chiamata; PHP lo chiama late static binding. Usa static:: e new static() nei metodi destinati a essere ereditati, e self:: quando intendi davvero questa esatta classe. La stessa regola vale per le costanti: static::TABLE prende il TABLE proprio di una figlia, mentre self::TABLE legge sempre quello della classe in cui è scritto il codice.

Le proprietà statiche ereditate sono condivise

Una classe figlia condivide la proprietà statica del padre a meno che non ne dichiari una propria. È la classica sorpresa di static: due sottoclassi che contano nello stesso numero.

<?php
class Counter
{
    public static int $count = 0;

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

class Apples extends Counter {}

class Pears extends Counter
{
    public static int $count = 0;   // its own copy
}

Apples::increment();
Apples::increment();
Pears::increment();

echo 'Counter: ', Counter::$count, "\n";
echo 'Apples: ', Apples::$count, "\n";
echo 'Pears: ', Pears::$count, "\n";

Apples non ha un $count proprio, quindi Apples::$count è Counter::$count, ed entrambi stampano 2. Pears ridichiara la proprietà e conta per conto suo. Una proprietà statica dichiarata in un trait si comporta diversamente: ogni classe che usa il trait riceve una copia separata.

Variabili statiche dentro le funzioni

static ha un secondo significato dentro il corpo di una funzione: una variabile statica mantiene il suo valore tra una chiamata e l'altra. Il valore iniziale viene assegnato solo la prima volta che la funzione viene eseguita:

<?php
function nextTicket(): string
{
    static $number = 0;
    $number++;
    return sprintf('T-%04d', $number);
}

echo nextTicket(), "\n";
echo nextTicket(), "\n";
echo nextTicket(), "\n";

// A simple cache: computed once, reused afterwards
function slowSquare(int $n): int
{
    static $cache = [];
    if (!isset($cache[$n])) {
        echo "(computing $n) ";
        $cache[$n] = $n * $n;
    }
    return $cache[$n];
}

echo slowSquare(12), "\n";
echo slowSquare(12), "\n";

Il secondo slowSquare(12) salta il calcolo. Come le proprietà statiche, questi valori si azzerano alla fine di ogni richiesta. La pagina sulle variabili tratta lo scope delle variabili in generale.

Quando static è la scelta sbagliata

I metodi statici sono comodi, e questo li rende facili da abusare. Una classe i cui metodi leggono e scrivono tutti proprietà statiche è stato globale con il nome di una classe sopra: ogni chiamante lo condivide, i test non possono averne una copia nuova e non puoi sostituirla con un'implementazione diversa.

<?php
// Static: one shared cart for the whole program
class StaticCart
{
    private static array $items = [];

    public static function add(string $item): void { self::$items[] = $item; }
    public static function items(): array { return self::$items; }
}

// Object: each cart is separate
class Cart
{
    private array $items = [];

    public function add(string $item): void { $this->items[] = $item; }
    public function items(): array { return $this->items; }
}

StaticCart::add('book');
StaticCart::add('pen');     // a "second customer" adds to the same cart
print_r(StaticCart::items());

$ada = new Cart();
$linus = new Cart();
$ada->add('book');
$linus->add('pen');
print_r($ada->items());
print_r($linus->items());

Buoni usi di static: funzioni di supporto pure senza stato (Slug::make()), costruttori con nome (Color::fromHex()) e costanti di classe. Se un metodo ha bisogno di dati che potrebbero cambiare tra due utilizzi, vuole un oggetto.