PHP static: métodos e propriedades estáticos, self e static

Um método ou propriedade static pertence à própria classe e não a um objeto. Você chama um método estático com ClassName::method() e lê uma propriedade estática com ClassName::$property, sem criar um objeto antes. Dentro da classe, self:: se refere aos mesmos membros.

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

Não há new Temperature() em lugar nenhum. Membros estáticos são úteis para funções auxiliares que não precisam de estado de objeto (conversões, fábricas, validação) e para dados que pertencem à classe como um todo, como um contador.

Propriedades estáticas são compartilhadas por todos os objetos

Uma propriedade normal tem um valor por objeto. Uma propriedade estática tem um valor para a classe inteira, então todos os objetos veem o mesmo. Aqui cada novo User incrementa um contador compartilhado e recebe o próximo 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";

Repare no $ em self::$nextId: propriedades estáticas o mantêm depois do ::, enquanto constantes (self::MAX) não. Uma propriedade estática vive só durante uma requisição PHP. Num site típico (PHP-FPM ou Apache), ela recomeça a cada carregamento de página, então não é lugar para guardar dados entre visitantes.

Métodos estáticos não têm $this

Um método estático roda sem objeto, então $this não existe dentro dele. Um método estático pode chamar outros métodos estáticos com self::, mas não pode ler propriedades normais. Chamar um método normal de forma estática também falha:

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

A direção oposta funciona: um método normal pode chamar métodos estáticos, como withSeparator() faz com self::make().

self ou static: late static binding

self:: aponta para a classe onde o código está escrito. static:: aponta para a classe em que o método foi chamado em tempo de execução. A diferença só aparece com herança, e importa mais em métodos de fábrica:

<?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() retorna um Model, o que quase nunca é o que quem chamou queria. static aponta para Post porque essa é a classe citada na chamada; o PHP chama isso de late static binding. Use static:: e new static() em métodos feitos para ser herdados, e self:: quando você realmente quer dizer esta classe exata. A mesma regra vale para constantes: static::TABLE pega o TABLE próprio de uma filha, enquanto self::TABLE sempre lê o da classe onde o código está escrito.

Propriedades estáticas herdadas são compartilhadas

Uma classe filha compartilha a propriedade estática da classe pai, a menos que declare a sua. Essa é a surpresa clássica do static: duas subclasses contando no mesmo número.

<?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 não tem um $count próprio, então Apples::$count é Counter::$count, e os dois imprimem 2. Pears redeclara a propriedade e conta sozinha. Uma propriedade estática declarada numa trait se comporta de outro jeito: cada classe que usa a trait recebe uma cópia separada.

Variáveis estáticas dentro de funções

static tem um segundo significado dentro do corpo de uma função: uma variável estática mantém o valor entre as chamadas. O valor inicial só é atribuído na primeira vez que a função roda:

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

O segundo slowSquare(12) pula o cálculo. Como as propriedades estáticas, esses valores recomeçam no fim de cada requisição. A página sobre variáveis explica o escopo de variáveis em geral.

Quando static é a escolha errada

Métodos estáticos são práticos, e isso os torna fáceis de usar demais. Uma classe cujos métodos todos leem e escrevem propriedades estáticas é estado global com um nome de classe: todos que chamam o compartilham, testes não conseguem uma cópia nova, e você não consegue trocar por outra implementação.

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

Bons usos de static: funções auxiliares puras sem estado (Slug::make()), construtores com nome (Color::fromHex()) e constantes da classe. Se um método precisa de dados que podem ser diferentes entre dois usos, ele quer um objeto.