PHP static: статические методы, свойства, self и static

Метод или свойство static принадлежит самому классу, а не какому-либо объекту. Статический метод вызывается через ClassName::method(), а статическое свойство читается через ClassName::$property, без предварительного создания объекта. Внутри класса к тем же членам обращаются через 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";

Нигде нет new Temperature(). Статические члены полезны для вспомогательных функций, которым не нужно состояние объекта (преобразования, фабрики, проверки), и для данных, которые принадлежат классу целиком, например счётчика.

Статические свойства общие для всех объектов

У обычного свойства по одному значению на объект. У статического свойства одно значение на весь класс, поэтому каждый объект видит одно и то же. Здесь каждый новый User увеличивает общий счётчик и получает следующий ID:

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

Обратите внимание на $ в self::$nextId: статические свойства сохраняют его после ::, а константы (self::MAX) нет. Статическое свойство живёт только в пределах одного запроса PHP. На типичном сайте (PHP-FPM или Apache) оно начинается заново при каждой загрузке страницы, поэтому хранить в нём данные между посетителями нельзя.

У статических методов нет $this

Статический метод выполняется без объекта, поэтому $this внутри него не существует. Статический метод может вызывать другие статические методы через self::, но не может читать обычные свойства. Вызов обычного метода статически тоже не работает:

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

Обратное направление допустимо: обычный метод может вызывать статические, как withSeparator() делает с self::make().

self и static: позднее статическое связывание

self:: указывает на класс, в котором написан код. static:: указывает на класс, для которого метод вызван во время выполнения. Разница проявляется только при наследовании, и важнее всего она для фабричных методов:

<?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() возвращает Model, а это почти никогда не то, что нужно вызывающему коду. static указывает на Post, потому что именно этот класс назван в вызове; PHP называет это поздним статическим связыванием. Используйте static:: и new static() в методах, которые предназначены для наследования, и self::, когда имеете в виду именно этот класс. То же правило работает для констант: static::TABLE берёт собственную TABLE дочернего класса, а self::TABLE всегда читает константу из класса, где написан код.

Унаследованные статические свойства общие

Дочерний класс разделяет статическое свойство родителя, если не объявит своё. Это классический сюрприз со static: два подкласса считают в одно число.

<?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 нет своего $count, поэтому Apples::$count это Counter::$count, и оба выводят 2. Pears переобъявляет свойство и считает отдельно. Статическое свойство, объявленное в трейте, ведёт себя иначе: каждый класс, использующий трейт, получает отдельную копию.

Статические переменные внутри функций

У static внутри тела функции есть второй смысл: статическая переменная сохраняет значение между вызовами. Начальное значение присваивается только при первом выполнении функции:

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

Второй slowSquare(12) пропускает вычисление. Как и статические свойства, эти значения сбрасываются в конце каждого запроса. Область видимости переменных в целом описана на странице о переменных.

Когда static это неправильный выбор

Статические методы удобны, и поэтому ими легко злоупотребить. Класс, все методы которого читают и пишут статические свойства, это глобальное состояние с именем класса: его разделяют все вызывающие, тесты не могут получить свежую копию, и подменить реализацию нельзя.

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

Хорошие применения static: чистые вспомогательные функции без состояния (Slug::make()), именованные конструкторы (Color::fromHex()) и константы на уровне класса. Если методу нужны данные, которые могут различаться между двумя использованиями, ему нужен объект.