Edit Report a Bug

    is_callable

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

    is_callable — Détermine si une valeur peut être appelé comme une fonction dans la portée courante.

    Description

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

    Vérifie qu'une variable est un callable.

    Liste de paramètres

    value

    La valeur à vérifier.

    syntax_only

    Si l'argument syntax_only vaut true, la fonction ne va vérifier que si value peut être une fonction ou une méthode. Il va simplement rejeter les variables qui ne sont pas des chaînes, ou des tableaux qui n'ont pas la bonne structure pour être utilisés comme fonction de rappel. Les tableaux valides sont supposés n'avoir que deux entrées, le premier étant un objet ou une chaîne, et le second une chaîne.

    callable_name

    L'argument callable_name reçoit le nom à utiliser. Dans l'exemple ci-dessous, il vaut "someClass::someMethod". Notez que, bien que someClass::someMethod() puisse être appelée sous forme statique, ce n'est pas le cas.

    Valeurs de retour

    Retourne true si value peut être appelé comme une fonction, false sinon.

    Exemples

    Exemple #1 Exemple avec is_callable()

    <?php
    // Comment vérifier qu'une variable peut être appelée
    // comme fonction ?

    //
    // Variable simple contenant une fonction
    //

    function someFunction()
    {
    }

    $functionVariable = 'someFunction';

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

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

    //
    // Tableau contenant une méthode
    //

    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

    ?>

    Exemple #2 is_callable() et les constructeurs

    is_callable() rapporte les constructeurs comme n'étant pas appelable.

    <?php

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

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

    L'exemple ci-dessus va afficher :

    bool(false)
bool(false)

    • Un object est tout le temps appelable s'il implémente __invoke(), et que la méthode est visible dans le portée courante.
    • Un nom de classe est appelable si elle implémente __callStatic()
    • Si un object implémente __call(), alors cette fonction retournera true pour n'importe quelle méthode sur cet object, même si la méthode n'est pas définie.
    • Cette fonction peut déclancher l'autochargement si appelé avec le nom d'une classe.

    Voir aussi

    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