Submit a Pull Request Report a Bug

    is_callable

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

    is_callable — Prüft, ob der Inhalt einer Variable als Funktion 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

    Liefert true, 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

    //
    //  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

    //
    //  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 Konstructoren

    Von PHP 5.3.0 an meldet is_callable() Konstruktoren als nicht aufrufbar. Dies betrifft Konstruktoren im PHP 5-Stil (__construct) wie auch Konstruktoren im PHP 4-Stil (d.h. Methoden mit demselben Namen wie die Klasse). Zuvor wurden beide Fälle als aufrufbar angesehen.

    <?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)

    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 5 notes

    up
    31
    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
    2
    rahadotaboulfethatgmail.com
    16 years ago
    is_callable generates an [E_STRICT] error if the  tested method cannot be called staticly. (and returns the good value)

    I used @is_called
    i'm using php 5.2.1
    up
    0
    jlh
    5 years ago
    The story about __call() is a bit more complicated unfortunately. It will always return true ONLY if you pass an instance of a class, not if you pass the class name itself:

    <?php
    class MyClass {
        public function     method() { }
        public function     __call($name, $arguments) { }
    }

    is_callable([MyClass::class, 'method']); // true
    is_callable([new MyClass(), 'method']); // true
    is_callable([MyClass::class, 'other']); // false!!!
    is_callable([new MyClass(), 'other'])); // true
    up
    0
    fgm at osinet dot fr
    12 years ago
    Note that, for the purpose of this function, an abstract method, although necessarily non-callable since it does not have a body, is still considered to be callable:

    <?php
    abstract class Foo {
      abstract function     bar();
    }

    echo     is_callable(array('Foo', 'bar'));
    // display: 1
    ?>
    up
    0
    Quis strrev TA omicidio strrev TOD com
    16 years ago
    is_callable() does _not_ check wheter this function is disabled by php.ini's disable_functions

    use:

    <?PHP
    function is_disabled($function) {
          $disabled_functions=explode(',',ini_get('disable_functions'));
      return     in_array($function, $disabled_functions);
    }
    ?>

    I`m running PHP 5.2.4
    add a note add a note
    To Top