static w PHP: metody i właściwości statyczne, self vs static

Metoda lub właściwość static należy do samej klasy, a nie do żadnego obiektu. Metodę statyczną wywołujesz przez ClassName::method(), a właściwość statyczną czytasz przez ClassName::$property, bez wcześniejszego tworzenia obiektu. Wewnątrz klasy do tych samych elementów odwołuje się self::.

<?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";

Nigdzie nie ma new Temperature(). Elementy statyczne przydają się w funkcjach pomocniczych, które nie potrzebują stanu obiektu (konwersje, fabryki, walidacja), i dla danych należących do klasy jako całości, takich jak licznik.

Właściwości statyczne są współdzielone przez wszystkie obiekty

Zwykła właściwość ma jedną wartość na obiekt. Właściwość statyczna ma jedną wartość dla całej klasy, więc każdy obiekt widzi tę samą. Tutaj każdy nowy User zwiększa wspólny licznik i dostaje kolejny identyfikator:

<?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";

Zwróć uwagę na $ w self::$nextId: właściwości statyczne zachowują go po ::, a stałe (self::MAX) nie. Właściwość statyczna żyje tylko przez jedno żądanie PHP. Na typowej stronie WWW (PHP-FPM lub Apache) zaczyna od nowa przy każdym wczytaniu strony, więc nie jest miejscem na przechowywanie danych między odwiedzającymi.

Metody statyczne nie mają $this

Metoda statyczna działa bez obiektu, więc nie istnieje w niej $this. Metoda statyczna może wywoływać inne metody statyczne przez self::, ale nie może czytać zwykłych właściwości. Statyczne wywołanie zwykłej metody też się nie udaje:

<?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";
}

Kierunek odwrotny jest w porządku: zwykła metoda może wywoływać metody statyczne, tak jak withSeparator() robi z self::make().

self vs static: późne wiązanie statyczne

self:: wskazuje klasę, w której napisano kod. static:: wskazuje klasę, na której wywołano metodę w czasie działania. Różnica wychodzi tylko przy dziedziczeniu, a najbardziej liczy się w metodach fabrycznych:

<?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() zwraca Model, czego wywołujący prawie nigdy nie chciał. static wskazuje na Post, bo to klasa wymieniona w wywołaniu; PHP nazywa to późnym wiązaniem statycznym (late static binding). Używaj static:: i new static() w metodach przeznaczonych do dziedziczenia, a self::, gdy naprawdę chodzi ci o tę konkretną klasę. Ta sama zasada dotyczy stałych: static::TABLE bierze własne TABLE potomka, a self::TABLE zawsze czyta to z klasy, w której napisano kod.

Odziedziczone właściwości statyczne są współdzielone

Klasa potomna współdzieli właściwość statyczną rodzica, chyba że zadeklaruje własną. To klasyczna niespodzianka ze static: dwie podklasy liczące do jednej liczby.

<?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 nie ma własnego $count, więc Apples::$count to Counter::$count i oba wypisują 2. Pears deklaruje właściwość ponownie i liczy osobno. Właściwość statyczna zadeklarowana w traicie zachowuje się inaczej: każda klasa używająca traitu dostaje osobną kopię.

Zmienne statyczne w funkcjach

static ma drugie znaczenie wewnątrz treści funkcji: zmienna statyczna zachowuje wartość między wywołaniami. Wartość początkowa jest przypisywana tylko przy pierwszym wykonaniu funkcji:

<?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";

Drugie slowSquare(12) pomija obliczenie. Podobnie jak właściwości statyczne, te wartości resetują się na koniec każdego żądania. Zasięg zmiennych ogólnie opisuje strona o zmiennych.

Kiedy static to zły wybór

Metody statyczne są wygodne i dlatego łatwo ich nadużywać. Klasa, której wszystkie metody czytają i zapisują właściwości statyczne, to stan globalny z nazwą klasy: współdzieli go każdy wywołujący, testy nie dostaną świeżej kopii, a podmiana implementacji jest niemożliwa.

<?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());

Dobre zastosowania static: czyste funkcje pomocnicze bez stanu (Slug::make()), nazwane konstruktory (Color::fromHex()) i stałe dla całej klasy. Jeśli metoda potrzebuje danych, które mogą się różnić między dwoma użyciami, potrzebuje obiektu.