is_callable()

Einführung

Die Funktion is_callable() prüft, ob ein Wert als Funktion aufgerufen werden kann — und gibt entsprechend true oder false zurück. Ein Wert ist callable, wenn PHP ihn aufrufen kann: ein eingebauter oder benutzerdefinierter Funktionsname, eine Methode, ein Closure oder ein Objekt, das __invoke() implementiert.

Diese Seite erklärt, was als callable gilt, die drei Parameter der Funktion (einschließlich der oft übersehenen Parameter $syntax_only und $callable_name), die vielen Formen, die ein callable annehmen kann, und die typischen Fallstricke. Der häufigste Anwendungsfall für is_callable() ist das Absichern eines Aufrufs — prüfen, ob ein Wert aufrufbar ist, bevor man ihn tatsächlich aufruft, damit man bei einem Fehler kontrolliert scheitert statt mit einem fatalen Fehler.

Syntax

is_callable(mixed $value, bool $syntax_only = false, string &$callable_name = null): bool

Die Funktion gibt einen bool zurück: true, wenn $value aufrufbar ist, andernfalls false.

Grundlegendes Beispiel

Die vier häufigsten callable-Formen — ein Funktionsname, eine Methode einer Instanz, eine statische Methode und ein nicht aufrufbarer string:

<?php
function testFunction()
{
    echo "Hello world!";
}

class TestClass
{
    public function testMethod() {}
    public static function staticMethod() {}
}

$var1 = "testFunction";                       // function name
$var2 = [new TestClass(), "testMethod"];      // [object, method]
$var3 = ["TestClass", "staticMethod"];        // [class, static method]
$var4 = "not_a_callable";                     // nothing by this name

var_dump(is_callable($var1)); // bool(true)
var_dump(is_callable($var2)); // bool(true)
var_dump(is_callable($var3)); // bool(true)
var_dump(is_callable($var4)); // bool(false)
?>

Hier wird var_dump() statt echo verwendet, weil das Ausgeben eines boolean mit echo 1 für true und einen leeren string für false ergibt — was leicht missverstanden werden kann. var_dump() zeigt den Typ explizit an.

Closures und aufrufbare Objekte

Ein Closure (anonyme Funktion) ist immer callable. Ebenso jedes Objekt, dessen Klasse die magische Methode __invoke() definiert — solche Objekte können mit der $obj()-Syntax aufgerufen werden:

<?php
$closure = function () { return "called"; };

class Multiplier
{
    public function __invoke($n) { return $n * 2; }
}

var_dump(is_callable($closure));            // bool(true)
var_dump(is_callable(new Multiplier()));    // bool(true)
var_dump(is_callable("strlen"));            // bool(true) — built-in functions count too
?>

Einen Aufruf absichern

Der wichtigste praktische Einsatz: erst prüfen, dann aufrufen, damit ein fehlerhafter Wert niemals einen fatalen Fehler auslöst.

<?php
function runIfPossible($maybeCallback)
{
    if (is_callable($maybeCallback)) {
        return $maybeCallback();
    }
    return "Nothing to run.";
}

echo runIfPossible(fn() => "It ran!") . "\n";   // It ran!
echo runIfPossible("missing_function") . "\n";  // Nothing to run.
?>

$syntax_only: Form vs. Existenz

Mit $syntax_only = true prüft is_callable() nur, ob der Wert die Form eines callable hat — es wird nicht bestätigt, dass das Ziel existiert. Das ist schneller, aber schwächer:

<?php
// "ghost" is not a real function:
var_dump(is_callable("ghost"));        // bool(false) — full check, fails
var_dump(is_callable("ghost", true));  // bool(true)  — syntax only, just "is a string"
?>

Verwende den Standard (false), wenn du den Wert tatsächlich aufrufen möchtest. Nutze true nur in den seltenen Fällen, in denen das Ziel später definiert wird (z. B. beim Registrieren von Callbacks, bevor ihre Funktionen geladen sind).

$callable_name: Den aufgelösten Namen abrufen

Der dritte Parameter wird per Referenz mit dem kanonischen Namen des callable befüllt — praktisch für Logging oder Fehlermeldungen:

<?php
class Greeter
{
    public function hello() {}
}

is_callable([new Greeter(), "hello"], false, $name);
echo $name . "\n";   // Greeter::hello

is_callable("trim", false, $name2);
echo $name2 . "\n";  // trim
?>

Häufige Fallstricke

• echo versteckt boolean-Werte. echo is_callable($x) gibt 1 für true und nichts für false aus. Bevorzuge var_dump() oder ein if.
• Private/protected Methoden sind von außen nicht aufrufbar. is_callable() respektiert die Sichtbarkeit — ein [object, 'privateMethod']-Paar gibt false zurück, wenn es von außerhalb des Klassenbereichs geprüft wird.
• is_callable() ist nicht function_exists(). function_exists() akzeptiert nur einen string als Funktionsnamen; is_callable() akzeptiert alle callable-Formen (Closures, Methoden-arrays, aufrufbare Objekte) — verwende es, wenn der Wert eine davon sein könnte.
• First-class callable Syntax (PHP 8.1+). strlen(...) erzeugt einen Closure, den is_callable() als true meldet.

Verwandte Funktionen

• callable-Typ — die vollständige Referenz dazu, was PHP als callable akzeptiert.
• Callback-Funktionen — Funktionen als Argumente übergeben.
• PHP-Funktionen — Funktionen definieren und aufrufen.
• Statische Methoden — die Class::method-callable-Form.
• is_object() — Prüfung auf aufrufbare Objekte.

Fazit

is_callable() beantwortet zuverlässig eine Frage: Kann ich diesen Wert aufrufen? Es erkennt Funktionsnamen, Methoden-arrays, statische Methoden, Closures und __invoke()-Objekte und respektiert dabei die Sichtbarkeitsregeln. Verwende es, um Aufrufe dynamischer Callbacks abzusichern, nutze $callable_name, um einen lesbaren Namen für Logs zu erhalten, und greife auf $syntax_only nur in dem speziellen Fall zurück, wenn das Ziel später definiert wird.

Übung