callable

L'indication de type callable en PHP

Un rappel (callback) est toute valeur que PHP peut invoquer comme une fonction — un nom de fonction ordinaire, une méthode sur un objet, une closure, etc. L'indication de type callable permet de déclarer qu'un paramètre, une propriété ou une valeur de retour doit être l'une de ces valeurs invocables. Combiné à un vrai appel ultérieur ($callback(...)), c'est le fondement des fonctions d'ordre supérieur comme array_map(), usort() et array_filter().

Cette page couvre la syntaxe, toutes les formes que peut prendre un callable, comment en valider un à l'exécution avec is_callable(), et les pièges qui font trébucher les développeurs.

Syntaxe

Ajoutez callable avant le nom du paramètre (ou comme type de propriété/retour) pour exiger une valeur invocable :

<?php

function run(callable $callback) {
  // $callback is guaranteed to be invocable here
  return $callback();
}

Si l'appelant passe quelque chose qui n'est pas callable, PHP lance une TypeError avant que le corps de votre fonction ne s'exécute — ainsi, à l'intérieur de la fonction, vous pouvez compter sur le bon fonctionnement de $callback().

Les cinq formes d'un callable

callable accepte plus qu'un simple nom de fonction. Chaque ligne ci-dessous est une valeur différente que PHP reconnaît comme rappel.

L'exemple ci-dessous les utilise tous avec un seul assistant run() :

<?php

function run(callable $callback): string
{
    return $callback();
}

// 1. A named function passed by string
function greet(): string
{
    return "Hello world!";
}
echo run('greet') . PHP_EOL;

// 2 & 3. Instance method and static method
class Greeter
{
    public function instanceHello(): string
    {
        return "Hello from an instance";
    }

    public static function staticHello(): string
    {
        return "Hello from a static method";
    }
}

$greeter = new Greeter();
echo run([$greeter, 'instanceHello']) . PHP_EOL; // instance method
echo run(['Greeter', 'staticHello']) . PHP_EOL;  // static method
echo run('Greeter::staticHello') . PHP_EOL;      // static method as a string

// 4. A closure (anonymous function)
echo run(function (): string {
    return "Hello from a closure";
}) . PHP_EOL;

// 5. An invokable object (has an __invoke method)
class Loud
{
    public function __invoke(): string
    {
        return "HELLO FROM __INVOKE";
    }
}
echo run(new Loud()) . PHP_EOL;

L'exécution de ce code affiche :

Hello world!
Hello from an instance
Hello from a static method
Hello from a static method
Hello from a closure
HELLO FROM __INVOKE

Vérifier une valeur avec is_callable()

Une indication de type valide l'entrée à la frontière de la fonction, mais parfois vous recevez une valeur de façon dynamique (depuis une configuration, une saisie utilisateur ou un registre) et souhaitez la vérifier avant de l'appeler. Utilisez is_callable() :

<?php

$maybe = 'strtoupper';

if (is_callable($maybe)) {
    echo $maybe('hi'), PHP_EOL; // HI
} else {
    echo "Not callable", PHP_EOL;
}

var_dump(is_callable('strtoupper'));        // bool(true)
var_dump(is_callable('no_such_function'));  // bool(false)
var_dump(is_callable([new DateTime(), 'format'])); // bool(true)

is_callable() retourne true uniquement si la cible existe réellement et est accessible — un nom de fonction mal orthographié retourne false au lieu de planter, ce qui en fait l'outil idéal pour du code de type plugin.

Syntaxe callable de première classe (PHP 8.1+)

Depuis PHP 8.1, vous pouvez transformer n'importe quelle fonction ou méthode en Closure avec la syntaxe (...). Cette approche est sûre pour les types, conviviale pour les IDE et évite les chaînes de caractères fragiles :

<?php

$upper = strtoupper(...);          // a Closure wrapping strtoupper
echo $upper('hello'), PHP_EOL;     // HELLO

$greeter = new DateTime('2020-01-01');
$fmt = $greeter->format(...);      // bound to $greeter
echo $fmt('Y'), PHP_EOL;           // 2020

Le résultat étant une Closure, il satisfait l'indication de type callable partout où un rappel est attendu.

Pièges courants

• Méthodes privées/protégées. Un callable [$object, 'method'] ne fonctionne que si la méthode est visible depuis l'endroit où elle est invoquée. Appeler une méthode privée via une string/un array depuis l'extérieur de sa classe échoue.
• callable ne peut pas être un type de propriété avant PHP 8.2 avec des nuances. L'utilisation de callable comme type de propriété de classe n'est pas autorisée ; stockez plutôt une Closure (ou \Closure), ou acceptez-la comme paramètre.
• Appel statique sans objet. [$object, 'staticMethod'] fonctionne, mais pour plus de clarté, préférez ['ClassName', 'staticMethod'] ou 'ClassName::staticMethod' pour les cibles statiques. Voir les méthodes statiques.
• Strings vs. objets. Un callable sous forme de string comme 'Greeter::staticHello' ne fonctionne que pour les méthodes statiques, pas les méthodes d'instance — les appels d'instance nécessitent la forme array [$object, 'method'].

Pourquoi utiliser callable ?

• Sécurité des types : PHP rejette les rappels invalides à l'endroit de l'appel avec une TypeError claire, plutôt que d'échouer profondément dans votre fonction.
• Signatures auto-documentées : les lecteurs (et les outils comme PHPStan ou Psalm) voient immédiatement qu'un paramètre est « quelque chose que je vais appeler ».
• Flexibilité : la même fonction accepte un nom de fonction, une méthode ou une closure — les appelants choisissent donc la forme la plus pratique.

Voir aussi

• Fonctions de rappel PHP — utiliser les callables avec array_map, usort et leurs équivalents.
• Fonctions PHP — définir les fonctions passées comme rappels.
• Méthodes statiques PHP — les formes de callable pour méthodes statiques.
• Types de données PHP — où callable s'inscrit parmi les types PHP.

Pratique