callable

Der PHP callable Type Hint

Ein Callback ist jeder Wert, den PHP wie eine Funktion aufrufen kann — ein einfacher Funktionsname, eine Methode eines Objekts, eine Closure und so weiter. Der callable Type Hint ermöglicht es, zu deklarieren, dass ein Parameter, eine Eigenschaft oder ein Rückgabewert einer dieser aufrufbaren Werte sein muss. Kombiniert mit einem späteren echten Aufruf ($callback(...)), bildet er die Grundlage von Higher-Order-Funktionen wie array_map(), usort() und array_filter().

Diese Seite behandelt die Syntax, alle Formen, die ein Callable annehmen kann, wie man einen zur Laufzeit mit is_callable() validiert, und die Fallstricke, über die man stolpern kann.

Syntax

Fügen Sie callable vor dem Parameternamen (oder als Eigenschafts-/Rückgabetyp) hinzu, um einen aufrufbaren Wert zu verlangen:

<?php

function run(callable $callback) {
  // $callback is guaranteed to be invocable here
  return $callback();
}

Wenn der Aufrufer etwas übergibt, das nicht callable ist, wirft PHP einen TypeError bevor der Funktionskörper ausgeführt wird — innerhalb der Funktion kann man sich also darauf verlassen, dass $callback() funktioniert.

Die fünf Formen eines Callable

callable akzeptiert mehr als nur einen Funktionsnamen. Jede Zeile unten ist ein anderer Wert, den PHP als Callback erkennt.

Das Beispiel unten testet alle davon mit einem einzigen run()-Hilfsprogramm:

<?php

function run(callable $callback): string
{
    return $callback();
}

// 1. A named function passed by string
function greet(): string
{
    return "Hello world!";
}
echo run('greet') . PHP_EOL;

// 2 & 3. Instance method and static method
class Greeter
{
    public function instanceHello(): string
    {
        return "Hello from an instance";
    }

    public static function staticHello(): string
    {
        return "Hello from a static method";
    }
}

$greeter = new Greeter();
echo run([$greeter, 'instanceHello']) . PHP_EOL; // instance method
echo run(['Greeter', 'staticHello']) . PHP_EOL;  // static method
echo run('Greeter::staticHello') . PHP_EOL;      // static method as a string

// 4. A closure (anonymous function)
echo run(function (): string {
    return "Hello from a closure";
}) . PHP_EOL;

// 5. An invokable object (has an __invoke method)
class Loud
{
    public function __invoke(): string
    {
        return "HELLO FROM __INVOKE";
    }
}
echo run(new Loud()) . PHP_EOL;

Die Ausführung gibt Folgendes aus:

Hello world!
Hello from an instance
Hello from a static method
Hello from a static method
Hello from a closure
HELLO FROM __INVOKE

Einen Wert mit is_callable() prüfen

Ein Type Hint validiert die Eingabe an der Funktionsgrenze, aber manchmal erhält man einen Wert dynamisch (aus einer Konfiguration, Benutzereingabe oder einer Registry) und möchte ihn vor dem Aufruf prüfen. Verwenden Sie is_callable():

<?php

$maybe = 'strtoupper';

if (is_callable($maybe)) {
    echo $maybe('hi'), PHP_EOL; // HI
} else {
    echo "Not callable", PHP_EOL;
}

var_dump(is_callable('strtoupper'));        // bool(true)
var_dump(is_callable('no_such_function'));  // bool(false)
var_dump(is_callable([new DateTime(), 'format'])); // bool(true)

is_callable() gibt true nur zurück, wenn das Ziel tatsächlich existiert und erreichbar ist — ein falsch geschriebener Funktionsname gibt false zurück, anstatt abzustürzen, was es ideal für Plugin-artigen Code macht.

First-Class-Callable-Syntax (PHP 8.1+)

Seit PHP 8.1 kann man jede Funktion oder Methode mit der (...)-Syntax in eine Closure umwandeln. Dies ist typsicher, IDE-freundlich und vermeidet fehleranfällige Strings:

<?php

$upper = strtoupper(...);          // a Closure wrapping strtoupper
echo $upper('hello'), PHP_EOL;     // HELLO

$greeter = new DateTime('2020-01-01');
$fmt = $greeter->format(...);      // bound to $greeter
echo $fmt('Y'), PHP_EOL;           // 2020

Da das Ergebnis eine Closure ist, erfüllt es den callable Type Hint überall, wo ein Callback erwartet wird.

Häufige Fallstricke

• Private/geschützte Methoden. Ein [$object, 'method']-Callable funktioniert nur, wenn die Methode von dem Ort aus sichtbar ist, von dem aus sie aufgerufen wird. Das Aufrufen einer privaten Methode über einen String/Array von außerhalb ihrer Klasse schlägt fehl.
• callable kann vor PHP 8.2 kein Eigenschaftstyp sein. Die Verwendung von callable als Eigenschaftstyp einer Klasse ist nicht erlaubt; speichern Sie stattdessen eine Closure (oder \Closure), oder akzeptieren Sie es als Parameter.
• Statischer Aufruf ohne Objekt. [$object, 'staticMethod'] funktioniert, aber der Klarheit halber sollte man für statische Ziele ['ClassName', 'staticMethod'] oder 'ClassName::staticMethod' bevorzugen. Siehe statische Methoden.
• Strings vs. Objekte. Ein String-Callable wie 'Greeter::staticHello' funktioniert nur für statische Methoden, nicht für Instanzmethoden — Instanzaufrufe benötigen die Array-Form [$object, 'method'].

Warum callable verwenden?

• Typsicherheit: PHP lehnt ungültige Callbacks an der Aufrufstelle mit einem klaren TypeError ab, anstatt tief in Ihrer Funktion zu scheitern.
• Selbstdokumentierende Signaturen: Leser (und Tools wie PHPStan oder Psalm) sehen sofort, dass ein Parameter "etwas ist, das ich aufrufen werde."
• Flexibilität: Die gleiche Funktion akzeptiert einen Funktionsnamen, eine Methode oder eine Closure — so können Aufrufer die praktischste Form wählen.

Siehe auch

• PHP-Callback-Funktionen — Verwendung von Callables mit array_map, usort und ähnlichen Funktionen.
• PHP-Funktionen — Definieren der Funktionen, die man als Callbacks übergibt.
• PHP statische Methoden — die Callable-Formen für statische Methoden.
• PHP-Datentypen — wo callable unter den PHP-Typen einzuordnen ist.

Übungen