is_callable()

Introdução

A função is_callable() verifica se um valor pode ser chamado como uma função — e retorna true ou false conforme o caso. Um valor é callable se o PHP consegue invocá-lo: um nome de função embutida ou definida pelo usuário, um método, um closure, ou um objeto que implementa __invoke().

Esta página aborda o que conta como callable, os três parâmetros da função (incluindo o frequentemente ignorado $syntax_only e $callable_name), as diversas formas que um callable pode ter, e as armadilhas que pegam as pessoas de surpresa. O motivo típico para usar is_callable() é proteger uma chamada — verificar se um valor é invocável antes de realmente invocá-lo, para falhar com elegância em vez de com um erro fatal.

Sintaxe

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

Retorna um bool: true se $value for callable, false caso contrário.

Exemplo básico

As quatro formas mais comuns de callable — um nome de função, um método em uma instância, um método estático e uma string não-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() aqui em vez de echo porque usar echo em um boolean imprime 1 para true e uma string vazia para false — o que é fácil de interpretar errado. var_dump() mostra o tipo explicitamente.

Closures e objetos invocáveis

Um Closure (função anônima) é sempre callable. O mesmo vale para qualquer objeto cuja classe define o método mágico __invoke() — esses objetos podem ser usados com a sintaxe $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
?>

Protegendo uma chamada antes de fazê-la

O principal uso prático: verificar primeiro e depois chamar, para que um valor inválido nunca provoque um erro 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: formato vs. existência

Com $syntax_only = true, is_callable() verifica apenas se o valor tem o formato de um callable — não confirma se o alvo existe. É mais rápido, mas menos rigoroso:

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

Use o padrão (false) quando pretender realmente chamar o valor. Reserve true para casos em que o alvo será definido mais tarde (por exemplo, registrar callbacks antes de as funções serem carregadas).

$callable_name: obtendo o nome resolvido

O terceiro parâmetro é preenchido por referência com o nome canônico do callable — útil para logs ou mensagens de erro:

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

Armadilhas comuns

• echo oculta booleans. echo is_callable($x) imprime 1 para true e nada para false. Prefira var_dump() ou um if.
• Métodos privados/protegidos não são callable de fora da classe. is_callable() respeita a visibilidade — um par [object, 'privateMethod'] retorna false quando verificado de fora do escopo da classe.
• is_callable() não é function_exists(). function_exists() aceita apenas uma string com o nome da função; is_callable() aceita todas as formas de callable (closures, arrays de método, objetos invocáveis) — use-o quando o valor puder ser qualquer um deles.
• Sintaxe callable de primeira classe (PHP 8.1+). strlen(...) produz um Closure, que is_callable() reporta como true.

Funções relacionadas

• tipo callable — a referência completa sobre o que o PHP aceita como callable.
• Funções de callback — passando funções como argumentos.
• Funções PHP — definindo e chamando funções.
• Métodos estáticos — a forma callable Class::method.
• is_object() — testando objetos invocáveis.

Conclusão

is_callable() responde a uma pergunta de forma confiável: posso chamar esse valor? Reconhece nomes de funções, arrays de método, métodos estáticos, closures e objetos com __invoke(), respeitando as regras de visibilidade. Use-o para proteger chamadas a callbacks dinâmicos, use $callable_name para recuperar um nome legível para logs, e recorra a $syntax_only apenas no caso específico em que o alvo é definido mais tarde.

Prática