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 que value est un callable, ou qu'il peut être appelé à l'aide de la fonction call_user_func().

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 rejettera toutes les valeurs qui ne sont pas des objets invocables, des Closure, des chaîne de caractèress, ou des tableaus qui n'ont pas une structure valide pour être utilisées comme un callback. Un tableau appelable valide contient 2 entrées : la première doit être un objet ou une chaîne de caractères, et la seconde une chaîne de caractères.
callable_name: Reçoit le "nom de la fonction callable", par exemple "SomeClass::someMethod". Notez cependant que, malgré l'implication selon laquelle SomeClass::someMethod() est une méthode statique callable, ce n'est pas le cas.

Valeurs de retour

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

Exemples

Exemple #1 Vérification si une chaîne peut être appelée comme une fonction

<?php

function someFunction() {}

$functionVariable = 'someFunction';

var_dump(is_callable($functionVariable, false, $callable_name));

var_dump($callable_name);

?>

L'exemple ci-dessus va afficher :

bool(true)
string(12) "someFunction"

Exemple #2 Vérification si un tableau peut être appelé comme une fonction

<?php

class someClass
{
    public function someMethod() {}
}

$anObject = new SomeClass();

$methodVariable = [$anObject, 'someMethod'];

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

var_dump($callable_name);

?>

L'exemple ci-dessus va afficher :

bool(true)
string(21) "SomeClass::someMethod"

Exemple #3 is_callable() et les constructeurs

Malgré le fait que les constructeurs sont les méthodes qui sont appelées lorsqu'un objet est créé, ils ne sont pas des méthodes statiques et is_callable() retournera false pour eux. Il n'est pas possible d'utiliser is_callable() pour vérifier si une classe peut être instanciée depuis la portée actuelle.

<?php

class Foo
{
    public function __construct() {}

    public function foo() {}
}

var_dump(
    is_callable(['Foo', '__construct']),
    is_callable(['Foo', 'foo'])
);

$foo = new Foo();
var_dump(is_callable([$foo, '__construct']));

?>

L'exemple ci-dessus va afficher :

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

Notes

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

call_user_func() - Appelle une fonction de rappel fournie par le premier argument
function_exists() - Indique si une fonction est définie
method_exists() - Vérifie si la méthode existe pour une classe

Found A Problem?

Learn How To Improve This Page • Submit a Pull Request • Report a Bug

＋add a note

User Contributed Notes 2 notes

down

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

down

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