is_callable — Funktion · PHP-Referenz

Signatur

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

Beschreibung

is_callable() überprüft, ob ein übergebener Wert ein gültiges Callable darstellt – also ob er tatsächlich als Funktion aufgerufen werden kann. Akzeptiert werden dabei einfache Funktionsnamen als String, statische Methoden im Format 'Klasse::Methode', Instanzmethoden als Array [$objekt, 'methode'] sowie anonyme Funktionen (Closure).

Mit dem Parameter $syntax_only lässt sich steuern, ob nur die syntaktische Gültigkeit des Callables geprüft wird (also ob es ein String oder ein Array mit maximal zwei Elementen ist), oder ob PHP tatsächlich nachsieht, ob die referenzierte Funktion bzw. Methode existiert und aufrufbar ist. Ohne $syntax_only wird eine vollständige Existenzprüfung durchgeführt.

Über den optionalen Referenz-Parameter $callable_name kann der kanonische Name des Callables abgerufen werden – etwa 'Klasse::Methode' für Methoden-Arrays. Dies ist nützlich für Debug-Ausgaben oder Logging.

Typische Einsatzgebiete sind die Validierung von Callback-Parametern in Frameworks und Libraries, das Absichern von Plugin-Systemen sowie die Implementierung von Dispatch-Tabellen, bei denen dynamisch entschieden wird, welche Funktion aufgerufen werden soll.

Parameter

Name	Typ	Default	Beschreibung
$value Pflicht	mixed		Der zu prüfende Wert. Kann ein Funktionsname als `string`, ein Array der Form `[$objekt, 'methode']` oder `['Klasse', 'methode']`, eine `Closure` oder ein Objekt mit der Methode `__invoke()` sein.
$syntax_only	bool	false	Wenn `true`, wird nur geprüft, ob `$value` syntaktisch ein aufrufbarer Typ ist (String oder Array mit 1–2 Elementen), ohne zu verifizieren, ob die Funktion/Methode tatsächlich existiert.
$callable_name	string		Wird per Referenz übergeben und erhält den kanonischen Namen des Callables, z. B. `'MeineKlasse::meineFunktion'`. Nützlich für Logging und Debugging.

Rückgabewert

Typ

bool

Beschreibung

Gibt true zurück, wenn $value aus dem aktuellen Geltungsbereich aufrufbar ist, andernfalls false. Bei $syntax_only = true wird nur die strukturelle Gültigkeit geprüft, nicht die tatsächliche Existenz der Funktion.

Beispiele

Verschiedene Callable-Typen prüfen

<?php
function meineFunktion(): void {}

$closure = function () {};

class MeineKlasse {
    public function methode(): void {}
    public static function statischeMethode(): void {}
}

$objekt = new MeineKlasse();

var_dump(is_callable('meineFunktion'));                        // true
var_dump(is_callable('nichtExistierendeFunktion'));            // false
var_dump(is_callable($closure));                              // true
var_dump(is_callable([$objekt, 'methode']));                  // true
var_dump(is_callable(['MeineKlasse', 'statischeMethode']));   // true
var_dump(is_callable('MeineKlasse::statischeMethode'));        // true

bool(true) bool(false) bool(true) bool(true) bool(true) bool(true)

Callback-Parameter in einer eigenen Funktion absichern

<?php
function verarbeiteElemente(array $daten, mixed $callback): array
{
    if (!is_callable($callback, false, $name)) {
        throw new InvalidArgumentException(
            "Der übergebene Callback '{$name}' ist nicht aufrufbar."
        );
    }

    return array_map($callback, $daten);
}

$ergebnis = verarbeiteElemente([1, 2, 3], fn(int $n) => $n * 2);
print_r($ergebnis);

try {
    verarbeiteElemente([1, 2, 3], 'nichtExistierend');
} catch (InvalidArgumentException $e) {
    echo $e->getMessage();
}

Array ( [0] => 2 [1] => 4 [2] => 6 ) Der übergebene Callback 'nichtExistierend' ist nicht aufrufbar.

syntax_only und callable_name verwenden

<?php
class Logger {
    public static function log(string $msg): void {
        echo $msg;
    }
}

$callable = ['Logger', 'log'];

if (is_callable($callable, false, $name)) {
    echo "Callable gefunden: {$name}\n";
    call_user_func($callable, "Hallo Welt!\n");
}

Callable gefunden: Logger::log Hallo Welt!

// Wichtig · Fallstricke

Sichtbarkeit beachten: is_callable() berücksichtigt den Geltungsbereich. Eine private oder protected Methode außerhalb der Klasse aufgerufen gibt false zurück, auch wenn die Methode existiert.

__invoke(): Objekte, die die magische Methode __invoke() implementieren, gelten ebenfalls als callable und werden von is_callable() als true erkannt.

Unterschied zu function_exists(): function_exists() prüft nur, ob eine Funktion mit dem angegebenen Namen existiert. is_callable() ist mächtiger, da es alle Callable-Typen (Closures, Methoden, Invokables) unterstützt.

Autoloading: Bei der Prüfung von Klassenmethoden kann is_callable() den Autoloader auslösen, was bei häufigen Prüfungen einen Performance-Einfluss haben kann.

Siehe auch

call_user_func function_exists method_exists array_map Closure