PHP static : méthodes, propriétés et self ou static

Une méthode ou une propriété static appartient à la classe elle-même plutôt qu'à un objet. Vous appelez une méthode statique avec ClassName::method() et lisez une propriété statique avec ClassName::$property, sans créer d'objet au préalable. Dans la classe, self:: désigne les mêmes membres.

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

Il n'y a aucun new Temperature(). Les membres statiques sont utiles pour des fonctions utilitaires qui n'ont pas besoin d'état d'objet (conversions, fabriques, validation) et pour des données qui appartiennent à la classe dans son ensemble, comme un compteur.

Les propriétés statiques sont partagées par tous les objets

Une propriété normale a une valeur par objet. Une propriété statique a une seule valeur pour toute la classe, donc chaque objet voit la même. Ici, chaque nouveau User incrémente un compteur partagé et reçoit l'identifiant suivant :

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

Notez le $ dans self::$nextId : les propriétés statiques le gardent après ::, contrairement aux constantes (self::MAX). Une propriété statique ne vit que le temps d'une requête PHP. Sur un site web classique (PHP-FPM ou Apache), elle repart de zéro à chaque chargement de page, ce n'est donc pas un endroit où stocker des données entre visiteurs.

Les méthodes statiques n'ont pas de $this

Une méthode statique s'exécute sans objet, donc $this n'existe pas dedans. Une méthode statique peut appeler d'autres méthodes statiques avec self::, mais ne peut pas lire les propriétés normales. Appeler une méthode normale de façon statique échoue aussi :

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

Le sens inverse ne pose pas de problème : une méthode normale peut appeler des méthodes statiques, comme le fait withSeparator() avec self::make().

self ou static : la liaison statique tardive

self:: désigne la classe où le code est écrit. static:: désigne la classe sur laquelle la méthode a été appelée à l'exécution. La différence n'apparaît qu'avec l'héritage, et elle compte surtout pour les méthodes de fabrique :

<?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() renvoie un Model, ce que l'appelant ne voulait presque jamais. static se résout en Post car c'est la classe nommée dans l'appel ; PHP appelle cela la liaison statique tardive (late static binding). Utilisez static:: et new static() dans les méthodes destinées à être héritées, et self:: quand vous voulez vraiment cette classe précise. La même règle s'applique aux constantes : static::TABLE prend le TABLE propre d'un enfant, alors que self::TABLE lit toujours celui de la classe où le code est écrit.

Les propriétés statiques héritées sont partagées

Une classe enfant partage la propriété statique de son parent, sauf si elle déclare la sienne. C'est la surprise classique de static : deux sous-classes qui comptent dans un même nombre.

<?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'a pas de $count à elle, donc Apples::$count est Counter::$count, et les deux affichent 2. Pears redéclare la propriété et compte de son côté. Une propriété statique déclarée dans un trait se comporte autrement : chaque classe qui utilise le trait en reçoit une copie séparée.

Les variables statiques dans les fonctions

static a un second sens dans le corps d'une fonction : une variable statique garde sa valeur entre les appels. La valeur initiale n'est affectée que la première fois que la fonction s'exécute :

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

Le second slowSquare(12) saute le calcul. Comme les propriétés statiques, ces valeurs sont réinitialisées à la fin de chaque requête. La page sur les variables traite de la portée des variables en général.

Quand static est le mauvais choix

Les méthodes statiques sont pratiques, et c'est ce qui pousse à en abuser. Une classe dont toutes les méthodes lisent et écrivent des propriétés statiques est un état global avec un nom de classe dessus : tous les appelants le partagent, les tests ne peuvent pas en obtenir une copie neuve, et vous ne pouvez pas le remplacer par une autre implémentation.

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

Les bons usages de static : des fonctions utilitaires pures sans état (Slug::make()), des constructeurs nommés (Color::fromHex()) et des constantes de classe. Si une méthode a besoin de données qui pourraient différer d'un usage à l'autre, elle réclame un objet.