callable

El tipo callable en PHP

Un callback es cualquier valor que PHP puede invocar como si fuera una función — un nombre de función simple, un método de un objeto, un closure, etc. El tipo callable permite declarar que un parámetro, propiedad o valor de retorno debe ser uno de estos valores invocables. Combinado con una llamada real posterior ($callback(...)), es la base de las funciones de orden superior como array_map(), usort() y array_filter().

Esta página cubre la sintaxis, todas las formas que puede adoptar un callable, cómo validarlo en tiempo de ejecución con is_callable() y los errores comunes que suelen sorprender a los desarrolladores.

Sintaxis

Añade callable antes del nombre del parámetro (o como tipo de propiedad/retorno) para requerir un valor invocable:

<?php

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

Si el llamador pasa algo que no es callable, PHP lanza un TypeError antes de que se ejecute el cuerpo de la función — por lo que dentro de la función puedes confiar en que $callback() funcionará.

Las cinco formas de un callable

callable acepta más que simples nombres de función. Cada fila a continuación es un valor diferente que PHP reconoce como callback.

El siguiente ejemplo ejercita todas ellas con un único helper 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;

Al ejecutarlo se imprime:

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

Comprobando un valor con is_callable()

Un tipo hint valida la entrada en el límite de la función, pero a veces recibes un valor dinámicamente (desde una configuración, entrada del usuario o un registro) y quieres comprobarlo antes de llamarlo. Usa 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() devuelve true solo si el objetivo existe realmente y es accesible — un nombre de función mal escrito devuelve false en lugar de causar un error, lo que lo hace ideal para código de tipo plugin.

Sintaxis callable de primera clase (PHP 8.1+)

Desde PHP 8.1 puedes convertir cualquier función o método en un Closure con la sintaxis (...). Es de tipo seguro, compatible con los IDE y evita strings frágiles:

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

Como el resultado es un Closure, satisface el tipo callable en cualquier lugar donde se espere un callback.

Errores comunes

• Métodos privados/protegidos. Un callable [$object, 'method'] solo funciona si el método es visible desde donde se invoca. Llamar a un método privado mediante string/array desde fuera de su clase falla.
• callable no puede ser tipo de propiedad antes de PHP 8.2 con advertencias. Usar callable como tipo de propiedad de clase no está permitido; almacena un Closure (o \Closure) en su lugar, o acéptalo como parámetro.
• Llamada estática sin objeto. [$object, 'staticMethod'] funciona, pero para mayor claridad prefiere ['ClassName', 'staticMethod'] o 'ClassName::staticMethod' para objetivos estáticos. Consulta métodos estáticos.
• Strings vs. objetos. Un callable string como 'Greeter::staticHello' solo funciona para métodos estáticos, no para métodos de instancia — las llamadas de instancia necesitan la forma de array [$object, 'method'].

¿Por qué usar callable?

• Seguridad de tipos: PHP rechaza los callbacks inválidos en el punto de llamada con un TypeError claro, en lugar de fallar en lo profundo de la función.
• Firmas autodocumentadas: los lectores (y herramientas como PHPStan o Psalm) ven inmediatamente que un parámetro es "algo que voy a llamar."
• Flexibilidad: la misma función acepta un nombre de función, un método o un closure — así los llamadores eligen la forma más conveniente.

Ver también

• Funciones callback de PHP — uso de callables con array_map, usort y similares.
• Funciones de PHP — definición de las funciones que se pasan como callbacks.
• Métodos estáticos de PHP — las formas de callable de método estático.
• Tipos de datos en PHP — dónde encaja callable entre los tipos de PHP.

Práctica