PHP static: métodos y propiedades estáticas, self vs static

Un método o una propiedad static pertenece a la propia clase y no a ningún objeto. Llamas a un método estático con ClassName::method() y lees una propiedad estática con ClassName::$property, sin crear antes un objeto. Dentro de la clase, self:: se refiere a los mismos miembros.

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

No hay ningún new Temperature() por ninguna parte. Los miembros estáticos son útiles para funciones auxiliares que no necesitan el estado de un objeto (conversiones, factorías, validación) y para datos que pertenecen a la clase en conjunto, como un contador.

Las propiedades estáticas las comparten todos los objetos

Una propiedad normal tiene un valor por objeto. Una propiedad estática tiene un valor para toda la clase, así que todos los objetos ven el mismo. Aquí cada nuevo User incrementa un contador compartido y recibe el siguiente 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";

Fíjate en el $ de self::$nextId: las propiedades estáticas lo conservan después de ::, mientras que las constantes (self::MAX) no. Una propiedad estática vive solo durante una petición de PHP. En un sitio web típico (PHP-FPM o Apache) vuelve a empezar con cada carga de página, así que no es un lugar para guardar datos entre visitantes.

Los métodos estáticos no tienen $this

Un método estático se ejecuta sin objeto, así que $this no existe dentro de él. Un método estático puede llamar a otros métodos estáticos con self::, pero no puede leer propiedades normales. Llamar a un método normal de forma estática también falla:

<?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 dirección contraria no da problemas: un método normal puede llamar a métodos estáticos, como hace withSeparator() con self::make().

self vs static: late static binding

self:: apunta a la clase donde está escrito el código. static:: apunta a la clase sobre la que se llamó el método en tiempo de ejecución. La diferencia solo aparece con herencia, y donde más importa es en los métodos factoría:

<?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() devuelve un Model, que casi nunca es lo que quería quien llamó. static se resuelve como Post porque esa es la clase nombrada en la llamada; PHP lo llama late static binding. Usa static:: y new static() en métodos pensados para heredarse, y self:: cuando realmente te refieras a esta clase exacta. La misma regla se aplica a las constantes: static::TABLE toma el TABLE propio de una hija, mientras que self::TABLE siempre lee el de la clase donde está escrito el código.

Las propiedades estáticas heredadas se comparten

Una clase hija comparte la propiedad estática de su padre salvo que declare la suya. Es la sorpresa clásica de static: dos subclases contando en un mismo 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 no tiene su propio $count, así que Apples::$count es Counter::$count, y los dos imprimen 2. Pears vuelve a declarar la propiedad y cuenta por su cuenta. Una propiedad estática declarada en un trait se comporta de otra forma: cada clase que usa el trait recibe una copia separada.

Variables estáticas dentro de funciones

static tiene un segundo significado dentro del cuerpo de una función: una variable estática conserva su valor entre llamadas. El valor inicial se asigna solo la primera vez que se ejecuta la función:

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

El segundo slowSquare(12) se salta el cálculo. Igual que las propiedades estáticas, estos valores se reinician al final de cada petición. La página de variables explica el ámbito de las variables en general.

Cuándo static es la opción equivocada

Los métodos estáticos son cómodos, y eso hace que sea fácil abusar de ellos. Una clase cuyos métodos leen y escriben propiedades estáticas es estado global con un nombre de clase encima: todos los que la llaman lo comparten, los tests no pueden obtener una copia limpia y no puedes sustituirla por otra implementación.

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

Buenos usos de static: funciones auxiliares puras sin estado (Slug::make()), constructores con nombre (Color::fromHex()) y constantes de toda la clase. Si un método necesita datos que podrían ser distintos entre dos usos, lo que quiere es un objeto.