Edit Report a Bug

    is_callable

    (PHP 4 >= 4.0.6, PHP 5, PHP 7, PHP 8)

    is_callable — Prüft, ob ein Wert als Funktion aus dem aktuellen Bereich aufgerufen werden kann.

    Beschreibung

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

    Prüft, ob ein Wert ein callable ist.

    Parameter-Liste

    value

    Der zu prüfende Wert.

    syntax_only

    Wenn dieser Parameter auf true gesetzt wird, prüft die Funktion nur, ob value eine Funktion oder Methode enthalten könnte. Nur einfache Variablen, die keinen String enthalten, werden zurückgewiesen, oder Arrays, die nicht die richtige Struktur haben, um als Callback verwendet werden zu können. Gültige Arrays müssen zwei Elemente haben, von denen der erste ein Objekt oder String und der zweite ein String ist.

    callable_name

    Hier wird der "aufrufbare Name" abgelegt. Für das Beispiel weiter unten ist dies "someClass::someMethod". Es ist zu beachten, dass dies keine statische Methode ist, auch wenn die Syntax das nahelegt.

    Rückgabewerte

    Gibt true zurück, wenn value aufrufbar ist, sonst false.

    Beispiele

    Beispiel #1 is_callable()-Beispiel

    <?php
    // Wie man prüft, ob eine Variable als Funktion aufgerufen werden kann

    //
    // Eine einfache Variable, die eine Funktion enthält
    //

    function someFunction()
    {
    }

    $functionVariable = 'someFunction';

    var_dump(is_callable($functionVariable, false, $callable_name)); // bool(true)

    echo $callable_name, "\n"; // someFunction

    //
    // Ein Array, das eine Methode enthält
    //

    class someClass {

    function     someMethod()
    {
    }

    }

    $anObject = new someClass();

    $methodVariable = array($anObject, 'someMethod');

    var_dump(is_callable($methodVariable, true, $callable_name)); // bool(true)

    echo $callable_name, "\n"; // someClass::someMethod

    ?>

    Beispiel #2 is_callable() und Konstruktoren

    is_callable() meldet Konstruktoren als nicht aufrufbar.

    <?php

    class Foo
    {
    public function     __construct() {}
    public function     foo() {}
    }

    var_dump(
    is_callable(array('Foo', '__construct')),
    is_callable(array('Foo', 'foo'))
    );

    Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

    bool(false)
bool(false)

    Anmerkungen

    • Ein Objekt ist immer aufrufbar, wenn es __invoke() implementiert und diese Methode im aktuellen Bereich sichtbar ist.
    • Ein Klassenname ist aufrufbar, wenn er __callStatic() implementiert.
    • Wenn ein Objekt __call() implementiert, dann wird diese Funktion für jede Methode dieses Objekts true zurückgeben, auch wenn die Methode nicht definiert ist.
    • Diese Funktion kann Autoloading auslösen, wenn sie mit dem Namen einer Klasse aufgerufen wird.

    Siehe auch

    • function_exists() - Falls die angegebene Funktion definiert ist, wird true zurück gegeben
    • method_exists() - Prüft ob eine Methode innerhalb eines Objekts existiert

    add a note add a note

    User Contributed Notes 2 notes

    up
    34
    izharaazmi at gmail dot com
    8 years ago
    If the target class has __call() magic function implemented, then is_callable will ALWAYS return TRUE for whatever method you call it.
    is_callable does not evaluate your internal logic inside __call() implementation (and this is for good).
    Therefore every method name is callable for such classes.

    Hence it is WRONG to say (as someone said):
    ...is_callable will correctly determine the existence of methods made with __call...

    Example:
    <?php
    class TestCallable
    {
        public function     testing()
        {
              return     "I am called.";
        }

        public function     __call($name, $args)
        {
            if(    $name == 'testingOther')
            {
                    return     call_user_func_array(array($this, 'testing'), $args);
            }
        }
    }

    $t = new TestCallable();
    echo     $t->testing();      // Output: I am called.
    echo $t->testingOther(); // Output: I am called.
    echo $t->working();      // Output: (null)

    echo is_callable(array($t, 'testing'));       // Output: TRUE
    echo is_callable(array($t, 'testingOther'));  // Output: TRUE
    echo is_callable(array($t, 'working'));       // Output: TRUE, expected: FALSE
    ?>
    up
    17
    mohamed dot elidrissi at protonmail dot com
    3 years ago
    Note that -- as mentioned in the migration guide-- starting from PHP 8.0, is_callable() will not work with non-static methods if you use a class name, instead an object of the class should be provided:

    <?php

    class Test
    {
        public function     method1() { }
        public static function     method2() { }
    }

    // Pre PHP 8
    var_dump(is_callable(array('Test', 'method1'))); // bool(true)
    var_dump(is_callable(array('Test', 'method2'))); // bool(true)

    // Post PHP 8
    var_dump(is_callable(array('Test', 'method1'))); // bool(false)
    var_dump(is_callable(array('Test', 'method2'))); // bool(true)
    var_dump(is_callable(array(new Test, 'method1'))); // bool(true)

    ?>
    add a note add a note
    To Top