forward_static_call — Funktion · PHP-Referenz

Signatur

forward_static_call(callable $callback, mixed ...$args): mixed

Beschreibung

forward_static_call() ist eine spezialisierte Variante von call_user_func(), die beim Weiterleiten eines Callbacks den Late Static Binding-Kontext (d. h. die tatsächlich aufgerufene Klasse) beibehält. Wo call_user_func() den Binding-Kontext verliert, stellt forward_static_call() sicher, dass static:: innerhalb des aufgerufenen Callbacks auf die korrekte, ursprünglich aufgerufene Klasse zeigt.

Die Funktion muss innerhalb einer Methode aufgerufen werden, da sie auf den aktuellen Methodenkontext angewiesen ist, um Late Static Binding weiterzugeben. Ein Aufruf außerhalb einer Klasse führt zu einem Fehler.

Typischer Anwendungsfall ist ein Vererbungs-Szenario, in dem eine Basisklasse eine Template-Methode besitzt, die eine statische Methode der abgeleiteten Klasse aufrufen soll – und dabei sicherstellt, dass static:: auf die konkrete Kindklasse verweist, nicht auf die Basisklasse.

Für Fälle, in denen zusätzlich ein Array von Argumenten übergeben werden soll, steht forward_static_call_array() zur Verfügung.

Parameter

Name	Typ	Default	Beschreibung
$callback Pflicht	callable		Der aufzurufende Callback, z. B. ein `'ClassName::methodName'`-String, ein Array `['ClassName', 'methodName']` oder ein Closure.
$args	mixed		Beliebig viele Argumente, die an den Callback übergeben werden (variadisch).

Rückgabewert

Typ

mixed

Beschreibung

Gibt den Rückgabewert des aufgerufenen Callbacks zurück, oder false im Fehlerfall.

Beispiele

Late Static Binding durch Vererbung weiterleiten

<?php
class Base {
    public static function create(): string {
        // Leitet den Aufruf an die eigene factory()-Methode weiter,
        // wobei static:: auf die tatsächlich aufgerufene Klasse zeigt
        return forward_static_call(['static', 'factory']);
    }

    public static function factory(): string {
        return 'Instanz von ' . static::class;
    }
}

class Child extends Base {
    public static function factory(): string {
        return 'Kindklassen-Instanz von ' . static::class;
    }
}

echo Base::create() . PHP_EOL;
echo Child::create() . PHP_EOL;

Instanz von Base Kindklassen-Instanz von Child

Vergleich mit call_user_func (ohne LSB)

<?php
class ParentClass {
    public static function dispatch(): string {
        // forward_static_call behält die aufgerufene Klasse bei
        return forward_static_call([static::class, 'greet']);
    }

    public static function greet(): string {
        return 'Hallo aus ' . static::class;
    }
}

class ChildClass extends ParentClass {
    public static function greet(): string {
        return 'Hallo speziell aus ' . static::class;
    }
}

// Aufruf über Kindklasse — static:: zeigt auf ChildClass
echo ChildClass::dispatch() . PHP_EOL;

// Direkter Aufruf via call_user_func verliert den LSB-Kontext
echo call_user_func(['ChildClass', 'greet']) . PHP_EOL;

Hallo speziell aus ChildClass Hallo speziell aus ChildClass

// Wichtig · Fallstricke

Nur innerhalb einer Methode nutzbar: forward_static_call() darf ausschließlich innerhalb einer Klassen-Methode aufgerufen werden. Ein Aufruf im globalen Scope erzeugt eine Warnung und gibt false zurück.

PHP 8.x: Ab PHP 8.0 kann in vielen Fällen direkt static::methodName() verwendet werden, was klarer und typsicherer ist. forward_static_call() ist vor allem dann nützlich, wenn der Callback-Name dynamisch bestimmt wird.

Für die Übergabe von Argumenten als Array empfiehlt sich forward_static_call_array(), das analog zu call_user_func_array() funktioniert.

Siehe auch

forward_static_call_array call_user_func call_user_func_array static