is_callable()

Introduction

La fonction is_callable() vérifie si une valeur peut être appelée comme une fonction — et retourne true ou false en conséquence. Une valeur est callable si PHP peut l'invoquer : un nom de fonction native ou définie par l'utilisateur, une méthode, une closure, ou un objet qui implémente __invoke().

Cette page couvre ce qui est considéré comme callable, les trois paramètres de la fonction (dont les souvent négligés $syntax_only et $callable_name), les nombreuses formes qu'un callable peut prendre, et les pièges courants. La raison typique d'utiliser is_callable() est de protéger un appel — vérifier qu'une valeur est invocable avant de l'appeler, pour échouer proprement plutôt qu'avec une erreur fatale.

Syntaxe

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

La fonction retourne un bool : true si $value est callable, false sinon.

Exemple de base

Les quatre formes callable les plus courantes — un nom de fonction, une méthode sur une instance, une méthode statique, et une chaîne non callable :

<?php
function testFunction()
{
    echo "Hello world!";
}

class TestClass
{
    public function testMethod() {}
    public static function staticMethod() {}
}

$var1 = "testFunction";                       // function name
$var2 = [new TestClass(), "testMethod"];      // [object, method]
$var3 = ["TestClass", "staticMethod"];        // [class, static method]
$var4 = "not_a_callable";                     // nothing by this name

var_dump(is_callable($var1)); // bool(true)
var_dump(is_callable($var2)); // bool(true)
var_dump(is_callable($var3)); // bool(true)
var_dump(is_callable($var4)); // bool(false)
?>

Nous utilisons var_dump() ici plutôt que echo car afficher un booléen avec echo imprime 1 pour true et une chaîne vide pour false — ce qui est facile à mal interpréter. var_dump() affiche le type explicitement.

Closures et objets invocables

Une Closure (fonction anonyme) est toujours callable. Il en va de même pour tout objet dont la classe définit la méthode magique __invoke() — ces objets peuvent être utilisés avec la syntaxe $obj() :

<?php
$closure = function () { return "called"; };

class Multiplier
{
    public function __invoke($n) { return $n * 2; }
}

var_dump(is_callable($closure));            // bool(true)
var_dump(is_callable(new Multiplier()));    // bool(true)
var_dump(is_callable("strlen"));            // bool(true) — built-in functions count too
?>

Protéger un appel avant de l'effectuer

L'utilisation pratique principale : vérifier d'abord, puis appeler, pour qu'une valeur incorrecte ne déclenche jamais une erreur fatale.

<?php
function runIfPossible($maybeCallback)
{
    if (is_callable($maybeCallback)) {
        return $maybeCallback();
    }
    return "Nothing to run.";
}

echo runIfPossible(fn() => "It ran!") . "\n";   // It ran!
echo runIfPossible("missing_function") . "\n";  // Nothing to run.
?>

$syntax_only : forme vs. existence

Avec $syntax_only = true, is_callable() vérifie uniquement que la valeur a la forme d'un callable — elle ne confirme pas que la cible existe. C'est plus rapide mais moins strict :

<?php
// "ghost" is not a real function:
var_dump(is_callable("ghost"));        // bool(false) — full check, fails
var_dump(is_callable("ghost", true));  // bool(true)  — syntax only, just "is a string"
?>

Utilisez la valeur par défaut (false) lorsque vous avez l'intention d'appeler réellement la valeur. Réservez true aux cas où la cible sera définie plus tard (par exemple, l'enregistrement de callbacks avant le chargement de leurs fonctions).

$callable_name : obtenir le nom résolu

Le troisième paramètre est rempli par référence avec le nom canonique du callable — pratique pour la journalisation ou les messages d'erreur :

<?php
class Greeter
{
    public function hello() {}
}

is_callable([new Greeter(), "hello"], false, $name);
echo $name . "\n";   // Greeter::hello

is_callable("trim", false, $name2);
echo $name2 . "\n";  // trim
?>

Pièges courants

• echo masque les booléens. echo is_callable($x) affiche 1 pour true et rien pour false. Préférez var_dump() ou un if.
• Les méthodes privées/protégées ne sont pas callable depuis l'extérieur. is_callable() respecte la visibilité — une paire [object, 'privateMethod'] retourne false lorsqu'elle est vérifiée depuis l'extérieur de la portée de la classe.
• is_callable() n'est pas function_exists(). function_exists() n'accepte qu'une chaîne de nom de fonction ; is_callable() accepte toutes les formes callable (closures, tableaux de méthodes, objets invocables) — utilisez-le lorsque la valeur peut être n'importe laquelle d'entre elles.
• Syntaxe callable de première classe (PHP 8.1+). strlen(...) produit une Closure, que is_callable() signale comme true.

Fonctions associées

• Type callable — la référence complète sur ce que PHP accepte comme callable.
• Fonctions callback — passer des fonctions comme arguments.
• Fonctions PHP — définir et appeler des fonctions.
• Méthodes statiques — la forme callable Class::method.
• is_object() — tester les objets invocables.

Conclusion

is_callable() répond à une question de manière fiable : puis-je appeler cette valeur ? Elle reconnaît les noms de fonctions, les tableaux de méthodes, les méthodes statiques, les closures et les objets __invoke(), tout en respectant les règles de visibilité. Utilisez-la pour protéger les appels aux callbacks dynamiques, utilisez $callable_name pour récupérer un nom lisible pour les journaux, et recourez à $syntax_only uniquement dans le cas particulier où la cible est définie plus tard.

Pratique