PHP static: Methoden, Eigenschaften und self vs static

Eine static-Methode oder -Eigenschaft gehört zur Klasse selbst statt zu einem Objekt. Eine statische Methode rufst du mit ClassName::method() auf, und eine statische Eigenschaft liest du mit ClassName::$property, ohne vorher ein Objekt zu erzeugen. In der Klasse verweist self:: auf dieselben Member.

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

Nirgendwo steht new Temperature(). Statische Member sind nützlich für Helfer, die keinen Objektzustand brauchen (Umrechnungen, Factories, Validierung), und für Daten, die zur Klasse als Ganzes gehören, etwa einen Zähler.

Statische Eigenschaften teilen sich alle Objekte

Eine normale Eigenschaft hat einen Wert pro Objekt. Eine statische Eigenschaft hat einen Wert für die ganze Klasse, also sieht jedes Objekt denselben. Hier erhöht jeder neue User einen gemeinsamen Zähler und bekommt die nächste 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";

Beachte das $ in self::$nextId: Statische Eigenschaften behalten es nach ::, Konstanten (self::MAX) nicht. Eine statische Eigenschaft lebt nur für eine PHP-Anfrage. Auf einer typischen Website (PHP-FPM oder Apache) beginnt sie bei jedem Seitenaufruf von vorn, ist also kein Ort, um Daten zwischen Besuchern zu speichern.

Statische Methoden haben kein $this

Eine statische Methode läuft ohne Objekt, also existiert $this darin nicht. Eine statische Methode kann andere statische Methoden mit self:: aufrufen, aber keine normalen Eigenschaften lesen. Eine normale Methode statisch aufzurufen scheitert ebenfalls:

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

Die umgekehrte Richtung ist kein Problem: Eine normale Methode kann statische aufrufen, wie es withSeparator() mit self::make() tut.

self vs static: Late Static Binding

self:: zeigt auf die Klasse, in der der Code steht. static:: zeigt auf die Klasse, auf der die Methode zur Laufzeit aufgerufen wurde. Der Unterschied zeigt sich nur bei Vererbung, und er zählt am meisten bei Factory-Methoden:

<?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() liefert ein Model, und das wollte der Aufrufer fast nie. static löst sich zu Post auf, weil das die im Aufruf genannte Klasse ist; PHP nennt das Late Static Binding. Verwende static:: und new static() in Methoden, die vererbt werden sollen, und self::, wenn du wirklich genau diese Klasse meinst. Dieselbe Regel gilt für Konstanten: static::TABLE nimmt das eigene TABLE eines Kindes, während self::TABLE immer das der Klasse liest, in der der Code steht.

Geerbte statische Eigenschaften werden geteilt

Eine Kindklasse teilt sich die statische Eigenschaft ihrer Elternklasse, außer sie deklariert eine eigene. Das ist die klassische static-Überraschung: zwei Unterklassen, die in eine einzige Zahl zählen.

<?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 hat kein eigenes $count, also ist Apples::$count dasselbe wie Counter::$count, und beide geben 2 aus. Pears deklariert die Eigenschaft neu und zählt für sich. Eine statische Eigenschaft, die in einem Trait deklariert ist, verhält sich anders: Jede Klasse, die den Trait verwendet, bekommt eine eigene Kopie.

Statische Variablen in Funktionen

static hat in einem Funktionsrumpf eine zweite Bedeutung: Eine statische Variable behält ihren Wert zwischen Aufrufen. Der Startwert wird nur beim ersten Aufruf der Funktion zugewiesen:

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

Das zweite slowSquare(12) überspringt die Berechnung. Wie statische Eigenschaften beginnen diese Werte am Ende jeder Anfrage von vorn. Die Seite zu Variablen behandelt den Scope von Variablen allgemein.

Wann static die falsche Wahl ist

Statische Methoden sind bequem, und genau deshalb werden sie leicht übertrieben. Eine Klasse, deren Methoden alle statische Eigenschaften lesen und schreiben, ist globaler Zustand mit einem Klassennamen darauf: Jeder Aufrufer teilt ihn, Tests bekommen keine frische Kopie, und du kannst keine andere Implementierung einsetzen.

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

Gute Einsätze für static: reine Helfer ohne Zustand (Slug::make()), benannte Konstruktoren (Color::fromHex()) und klassenweite Konstanten. Wenn eine Methode Daten braucht, die sich zwischen zwei Verwendungen unterscheiden könnten, will sie ein Objekt.