PHP: Type hinting - Diferença entre `Closure` e` Callable`

Percebi que posso usar um Closureou outro Callabletipo de dica se esperávamos que alguma função de retorno de chamada fosse executada. Por exemplo:

function callFunc1(Closure $closure) {
    $closure();
}

function callFunc2(Callable $callback) {
    $callback();
}

$function = function() {
    echo 'Hello, World!';
};

callFunc1($function); // Hello, World!
callFunc2($function); // Hello, World!

Questão:

Qual a diferença aqui? Em outras palavras, quando usar Closuree quando usar CallableOU eles servem ao mesmo propósito?

A diferença é que a Closuredeve ser uma função anônima, onde callabletambém pode ser uma função normal.

Você pode ver / testar isso com o exemplo abaixo e verá que receberá um erro no primeiro:

function callFunc1(Closure $closure) {
    $closure();
}

function callFunc2(Callable $callback) {
    $callback();
}

function xy() {
    echo 'Hello, World!';
}

callFunc1("xy"); // Catchable fatal error: Argument 1 passed to callFunc1() must be an instance of Closure, string given
callFunc2("xy"); // Hello, World!

Portanto, se você deseja apenas digitar dica, use a função anônima: Closuree se deseja também permitir funções normais, use callablecomo dica.

A principal diferença entre eles é que a closureé uma classe e callableum tipo .

O callabletipo aceita qualquer coisa que possa ser chamada :

var_dump(
  is_callable('functionName'),
  is_callable([$myClass, 'methodName']),
  is_callable(function(){})
);

Quando um closurevai única aceitar uma função anônima. Note que no PHP versão 7.1 você pode converter funções para um fecho assim: Closure::fromCallable('functionName').

Exemplo:

namespace foo{
  class bar{
    private $val = 10;

    function myCallable(callable $cb){$cb()}
    function myClosure(\Closure $cb){$cb()} // type hint must refer to global namespace
  }

  function func(){}
  $cb = function(){};
  $fb = new bar;

  $fb->myCallable(function(){});
  $fb->myCallable($cb);
  $fb->myCallable('func');

  $fb->myClosure(function(){});
  $fb->myClosure($cb);
  $fb->myClosure(\Closure::fromCallable('func'));
  $fb->myClosure('func'); # TypeError
}

Então, por que usar um closureover callable?

Rigor porque um closureé um objecto que tem alguns métodos adicionais: call(), bind()e bindto(). Eles permitem que você use uma função declarada fora de uma classe e execute-a como se estivesse dentro de uma classe.

$inject = function($i){return $this->val * $i;};
$cb1 = Closure::bind($inject, $fb);
$cb2 = $inject->bindTo($fb);

echo $cb1->call($fb, 2); // 20
echo $cb2(3);            // 30

Você não gostaria de chamar métodos com uma função normal, pois isso gerará erros fatais. Portanto, para contornar você teria que escrever algo como:

if($cb instanceof \Closure){}

Para fazer isso, verifique sempre que não faz sentido. Portanto, se você deseja usar esses métodos, declare que o argumento é a closure. Caso contrário, basta usar um normal callback. Deste jeito; Um erro é gerado na chamada de função em vez do seu código, tornando-o muito mais fácil de diagnosticar.

Em uma nota lateral: A closureturma não pode ser estendida como final .

Vale ressaltar que isso não funcionará nas versões 5.3.21 a 5.3.29 do PHP.

Em qualquer uma dessas versões, você obterá uma saída como:

Olá Mundo! Erro fatal detectável: o argumento 1 passado para callFunc2 () deve ser uma instância de> Callable, instância de Closure fornecida, chamada em / in / kqeYD na linha 16 e definida em / in / kqeYD na linha 7

Processo encerrado com o código 255.

Pode-se tentar isso usando https://3v4l.org/kqeYD#v5321

Cumprimentos,