forward_static_call_array — Funktion · PHP-Referenz

Signatur

forward_static_call_array(callable $callback, array $args): mixed

Beschreibung

forward_static_call_array() funktioniert wie forward_static_call(), nimmt jedoch die Argumente als Array entgegen statt als einzelne Parameter. Die Funktion leitet einen statischen Methodenaufruf weiter und bewahrt dabei den Late-Static-Binding-Kontext (LSB): Die aufgerufene Methode erhält über static:: dieselbe Klasse, die den ursprünglichen Aufruf ausgelöst hat.

Dies ist besonders nützlich in Vererbungshierarchien, wenn eine übergeordnete Klasse eine statische Methode aufruft, die in einer abgeleiteten Klasse überschrieben wurde, und dabei sicherstellen möchte, dass static:: auf die tatsächliche, aufrufende Klasse zeigt – nicht auf die definierende Klasse.

Im Gegensatz zu call_user_func_array() überträgt forward_static_call_array() den LSB-Kontext, sodass die aufgerufene Funktion weiß, aus welcher Klasse der Aufruf ursprünglich kam. Die Funktion darf nur innerhalb einer Klassen-Methode verwendet werden; ein Aufruf außerhalb einer Klasse erzeugt einen Fehler.

Wenn die Argumentliste variabel oder bereits als Array vorliegt, ist forward_static_call_array() der bevorzugte Weg gegenüber forward_static_call(), das einzelne Argumente erwartet.

Parameter

Name	Typ	Default	Beschreibung
$callback Pflicht	callable		Der aufzurufende Callback. Kann ein String (`'KlassenName::methode'`), ein Array (`['KlassenName', 'methode']`) oder ein anderer gültiger PHP-Callable sein.
$args Pflicht	array		Ein indiziertes Array mit den Argumenten, die an den Callback weitergegeben werden sollen.

Rückgabewert

Typ

mixed

Beschreibung

Gibt den Rückgabewert des aufgerufenen Callbacks zurück, oder false bei einem Fehler.

Beispiele

Statischen Aufruf in Vererbungshierarchie weiterleiten

<?php
class Base
{
    public static function create(string $name, int $value): static
    {
        // Gibt die tatsächlich aufrufende Klasse zurück (LSB)
        echo "Erstelle via " . static::class . ": $name=$value\n";
        return new static();
    }

    public static function factory(array $args): static
    {
        // Leitet den Aufruf mit LSB-Kontext weiter
        return forward_static_call_array(['static', 'create'], $args);
    }
}

class Child extends Base
{
    public static function create(string $name, int $value): static
    {
        echo "Child-Implementierung: $name=$value\n";
        return new static();
    }
}

// Aufruf über Child – LSB sorgt dafür, dass Child::create() aufgerufen wird
$obj = Child::factory(['meinObjekt', 42]);

Child-Implementierung: meinObjekt=42

Vergleich mit call_user_func_array (kein LSB)

<?php
class A
{
    public static function whoAmI(): string
    {
        return static::class; // Late-Static-Binding
    }

    public static function testForward(): string
    {
        // Erhält den LSB-Kontext
        return forward_static_call_array(['static', 'whoAmI'], []);
    }

    public static function testCall(): string
    {
        // Verliert den LSB-Kontext, gibt immer 'A' zurück
        return call_user_func_array(['static', 'whoAmI'], []);
    }
}

class B extends A {}

echo B::testForward() . "\n"; // Gibt 'B' aus (LSB erhalten)
echo B::testCall()   . "\n"; // Gibt 'A' aus (LSB verloren)

B A

// Wichtig · Fallstricke

Wichtig: forward_static_call_array() kann nur innerhalb einer statischen oder regulären Methode einer Klasse aufgerufen werden. Der Aufruf aus dem globalen Scope oder aus einer normalen Funktion außerhalb einer Klasse führt zu einem E_WARNING-Fehler und gibt false zurück.

Ab PHP 8.0 kann in vielen Fällen der Spread-Operator (ClassName::methode(...$args)) als modernere Alternative verwendet werden, der ebenfalls den LSB-Kontext bewahrt, wenn static:: eingesetzt wird. forward_static_call_array() bleibt jedoch nützlich, wenn der Callable dynamisch zur Laufzeit bestimmt wird.

Siehe auch

forward_static_call call_user_func_array call_user_func static Late Static Binding