is_callable()

Introduzione

La funzione is_callable() verifica se un valore può essere chiamato come una funzione — e restituisce true o false di conseguenza. Un valore è callable se PHP è in grado di invocarlo: il nome di una funzione predefinita o definita dall'utente, un metodo, una closure oppure un oggetto che implementa __invoke().

Questa pagina spiega cosa si considera callable, i tre parametri della funzione (inclusi i meno noti $syntax_only e $callable_name), le molte forme che un callable può assumere e le insidie più comuni. Il motivo tipico per usare is_callable() è proteggere una chiamata — verificare che un valore sia invocabile prima di invocarlo davvero, per gestire gli errori in modo elegante anziché con un errore fatale.

Sintassi

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

Restituisce un valore bool: true se $value è callable, false altrimenti.

Esempio di base

Le quattro forme di callable più comuni — un nome di funzione, un metodo su un'istanza, un metodo statico e una stringa 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)
?>

Qui si usa var_dump() invece di echo perché stampare un boolean con echo produce 1 per true e una stringa vuota per false — facilmente fraintendibile. var_dump() mostra il tipo in modo esplicito.

Closure e oggetti invocabili

Una Closure (funzione anonima) è sempre callable. Lo è anche qualsiasi oggetto la cui classe definisce il metodo magico __invoke() — tali oggetti possono essere usati con la sintassi $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
?>

Proteggere una chiamata prima di effettuarla

L'uso pratico principale: controllare prima e poi chiamare, in modo che un valore errato non causi mai un errore 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: forma vs. esistenza

Con $syntax_only = true, is_callable() controlla solo che il valore abbia la forma di un callable — non conferma che il target esista. Questo è più veloce ma meno affidabile:

<?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 il valore predefinito (false) quando intendi effettivamente chiamare il valore. Riserva true ai casi in cui il target verrà definito in seguito (ad esempio, quando si registrano callback prima che le relative funzioni vengano caricate).

$callable_name: ottenere il nome risolto

Il terzo parametro viene popolato per riferimento con il nome canonico del callable — utile per il logging o i messaggi di errore:

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

Insidie comuni

• echo nasconde i boolean. echo is_callable($x) stampa 1 per true e niente per false. Preferisci var_dump() o un costrutto if.
• I metodi privati/protetti non sono callable dall'esterno. is_callable() rispetta la visibilità — una coppia [object, 'privateMethod'] restituisce false se controllata dall'esterno dello scope della classe.
• is_callable() non è function_exists(). function_exists() accetta solo una stringa con il nome della funzione; is_callable() accetta ogni forma callable (closure, array di metodi, oggetti invocabili) — usala quando il valore potrebbe essere una qualsiasi di esse.
• Sintassi callable di prima classe (PHP 8.1+). strlen(...) produce una Closure, che is_callable() riporta come true.

Funzioni correlate

• tipo callable — la guida completa su cosa PHP accetta come callable.
• Funzioni callback — passare funzioni come argomenti.
• Funzioni PHP — definire e chiamare funzioni.
• Metodi statici — la forma callable Class::method.
• is_object() — verifica di oggetti invocabili.

Conclusione

is_callable() risponde in modo affidabile a un'unica domanda: posso chiamare questo valore? Riconosce nomi di funzioni, array di metodi, metodi statici, closure e oggetti __invoke(), rispettando le regole di visibilità. Usala per proteggere le chiamate a callback dinamici, usa $callable_name per recuperare un nome leggibile nei log, e ricorri a $syntax_only solo nel caso specifico in cui il target verrà definito in seguito.

Esercizio