is_callable()

Introducción

La función is_callable() comprueba si un valor puede ser invocado como una función y devuelve true o false según corresponda. Un valor es callable (invocable) si PHP puede llamarlo: el nombre de una función incorporada o definida por el usuario, un método, un closure o un objeto que implemente __invoke().

Esta página cubre qué se considera callable, los tres parámetros de la función (incluidos los frecuentemente ignorados $syntax_only y $callable_name), las múltiples formas que puede tener un callable y los errores comunes que suelen sorprender a los desarrolladores. La razón típica para usar is_callable() es proteger una llamada — verificar que un valor es invocable antes de invocarlo realmente, para fallar de forma controlada en lugar de con un error fatal.

Sintaxis

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

Devuelve un bool: true si $value es callable, false en caso contrario.

Ejemplo básico

Las cuatro formas más comunes de callable — un nombre de función, un método sobre una instancia, un método estático y un string no 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)
?>

Usamos var_dump() en lugar de echo porque al imprimir un boolean con echo se muestra 1 para true y una cadena vacía para false — lo cual es fácil de malinterpretar. var_dump() muestra el tipo de forma explícita.

Closures y objetos invocables

Un Closure (función anónima) siempre es callable. También lo es cualquier objeto cuya clase defina el método mágico __invoke() — esos objetos pueden usarse con la sintaxis $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
?>

Proteger una llamada antes de realizarla

El uso práctico principal: comprobar primero y luego llamar, para que un valor incorrecto nunca provoque un error fatal.

<?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: forma vs. existencia

Con $syntax_only = true, is_callable() solo comprueba que el valor tenga la forma de un callable — no confirma que el objetivo exista. Esto es más rápido pero menos riguroso:

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

Usa el valor por defecto (false) cuando vayas a llamar realmente al valor. Reserva true para casos donde el objetivo se definirá más adelante (por ejemplo, registrar callbacks antes de que sus funciones se carguen).

$callable_name: obtener el nombre resuelto

El tercer parámetro se rellena por referencia con el nombre canónico del callable — útil para logs o mensajes de error:

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

Errores comunes

• echo oculta los booleanos. echo is_callable($x) imprime 1 para true y nada para false. Prefiere var_dump() o un if.
• Los métodos privados/protegidos no son callable desde fuera. is_callable() respeta la visibilidad — un par [object, 'privateMethod'] devuelve false cuando se comprueba desde fuera del ámbito de la clase.
• is_callable() no es function_exists(). function_exists() solo acepta un string con el nombre de una función; is_callable() acepta cualquier forma callable (closures, arrays de métodos, objetos invocables) — úsalo cuando el valor pueda ser cualquiera de ellos.
• Sintaxis callable de primera clase (PHP 8.1+). strlen(...) produce un Closure, que is_callable() reporta como true.

Funciones relacionadas

• Tipo callable — la referencia completa sobre lo que PHP acepta como callable.
• Funciones de callback — pasar funciones como argumentos.
• Funciones PHP — definir e invocar funciones.
• Métodos estáticos — la forma callable Class::method.
• is_object() — comprobar si un objeto es invocable.

Conclusión

is_callable() responde de forma fiable a una pregunta: ¿puedo llamar a este valor? Reconoce nombres de funciones, arrays de métodos, métodos estáticos, closures y objetos con __invoke(), respetando las reglas de visibilidad. Úsalo para proteger llamadas a callbacks dinámicos, usa $callable_name para obtener un nombre legible para los logs, y recurre a $syntax_only solo en el caso concreto donde el objetivo se definirá más adelante.

Práctica