Um chamável é uma referência a uma função ou a um método que é passada a outra função como um argumento. Chamáveis são representados com a declaração de tipo callable.
<?php
function foo(callable $callback) {
$callback();
}
?>Algumas funções aceitam funções como um parâmetro, por exemplo, array_map(), usort() ou preg_replace_callback().
Um objeto chamável é um tipo que representa algo que pode ser invocado. Os objetos invocáveis podem ser passados como argumentos para funções ou métodos que esperam um parâmetro de função de retorno (callback) ou podem ser invocados diretamente. O tipo callable não pode ser usado como uma declaração de tipo para propriedades de classe. Em vez disso, use uma declaração de tipo Closure.
Chamáveis podem ser criados de diferentes formas:
Um objeto Closure pode ser criado usando-se a sintaxe de função anônima, de função seta, de chamável de primeira classe, ou com o médoto Closure::fromCallable().
Nota: A sintaxe de chamável de primeira classe está disponível somente a partir do PHP 8.1.0.
Exemplo #1 Exemplo de função de retorno usando Closure
<?php
// Usando a sintaxe de função anônima
$double1 = function ($a) {
return $a * 2;
};
// Usando a sintaxe de chamável de primeira classe
function double_function($a) {
return $a * 2;
}
$double2 = double_function(...);
// Usando a sintaxe de função seta
$double3 = fn($a) => $a * 2;
// Usando Closure::fromCallable
$double4 = Closure::fromCallable('double_function');
// Usando o closure como uma função de retorno aqui para
// duplicar o tamanho de cada elemento no intervalo
$new_numbers = array_map($double1, range(1, 5));
print implode(' ', $new_numbers) . PHP_EOL;
$new_numbers = array_map($double2, range(1, 5));
print implode(' ', $new_numbers) . PHP_EOL;
$new_numbers = array_map($double3, range(1, 5));
print implode(' ', $new_numbers) . PHP_EOL;
$new_numbers = array_map($double4, range(1, 5));
print implode(' ', $new_numbers);
?>Saída do exemplo acima no PHP 8.1:
2 4 6 8 10 2 4 6 8 10 2 4 6 8 10 2 4 6 8 10
Um chamável também pode ser uma string contendo o nome de uma função ou de um método estático. Qualquer função interna ou definida pelo usuário pode ser utilizada, com exceção dos construtores de linguagem como: array(), echo, empty(), eval(), isset(), list(), print ou unset().
Métodos estáticos também podem ser passados sem a instância de um
object dessa classe criando um array com
o nome da classe no índice 0 e o nome do método no índice 1 ou usando
a sintaxe especial com operador de resolução de escopo
:: como em 'ClassName::methodName'.
Um método de um object instanciado pode ser um chamável quando fornecido como um array com o object no índice 0 e o nome do método no índice 1.
A principal diferença entre um objeto Closure e o tipo callable é que um objeto Closure é independente de escopo e sempre pode ser invocado, enquanto um tipo 'callable' pode ser dependente de escopo e pode não ser invocado diretamente. Closure é a maneira preferida de criar objetos chamáveis.
Nota: Embora os objetos Closure estejam vinculados ao escopo onde são criados, os objetos chamáveis que referenciam métodos de classe como strings ou arrays são resolvidos no escopo onde são chamados. Para criar um objeto chamável a partir de um método privado ou protegido, que pode então ser invocado de fora do escopo da classe, use Closure::fromCallable() ou a sintaxe de chamável de primeira classe.
O PHP permite a criação de chamáveis que podem ser usados como argumento de função de retorno
mas não podem ser chamadas diretamente.
Essas são funções dependentes do contexto que fazem referência a um método de classe na
hierarquia de herança de uma classe, por exemplo:
'parent::method' ou ["static", "method"].
Nota: A partir do PHP 8.2.0, chamáveis dependentes de contexto foram descontinuados. Remova a dependência de contexto substituindo
'parent::method'porparent::class . '::method'ou use a sintaxe de chamável de primeira classe.
Exemplo #2 Invocando vários tipos de chamáveis com call_user_function()
<?php
// Exemplo de função de retorno
function minha_funcao_retorno() {
echo 'olá mundo!', PHP_EOL;
}
// Exemplo de método de retorno
class MinhaClasse {
static function meuMetodoRetorno() {
echo 'Olá Mundo!', PHP_EOL;
}
}
// Tipo 1: Função de Retorno Simples
call_user_func('minha_funcao_retorno');
// Tipo 2: Chamada a métodos estáticos
call_user_func(['MinhaClasse', 'meuMetodoRetorno']);
// Tipo 3: Chamada a métodos de objetos
$obj = new MinhaClasse();
call_user_func([$obj, 'meuMetodoRetorno']);
// Tipo 4: Chamada a métodos estáticos
call_user_func('MinhaClasse::meuMetodoRetorno');
// Tipo 5: Chamada a métodos estáticos usando a palavra-chave ::class
call_user_func([MyClass::class, 'myCallbackMethod']);
// Type 6: Relative static class method call
class A {
public static function quem() {
echo "A\n", PHP_EOL;
}
}
class B extends A {
public static function quem() {
echo "B\n", PHP_EOL;
}
}
call_user_func(['B', 'parent::quem']); // descontinuado a partir do PHP 8.2.0
// Type 7: Objetos que implementam __invoke podem ser utilizados como chamáveis
class C {
public function __invoke($nome) {
echo 'Olá ', $nome;
}
}
$c = new C();
call_user_func($c, 'PHP!');
?>O exemplo acima produzirá:
olá mundo! Olá Mundo! Olá Mundo! Olá Mundo! Olá Mundo! Deprecated: Callables of the form ["B", "parent::who"] are deprecated in script on line 41 A Olá, PHP!
Nota:
Callbacks registrados com funções como call_user_func() e call_user_func_array() não serão chamados se houver uma exceção não capturada que foi lançada em um callback anterior.
You can also use the $this variable to specify a callback:
<?php
class MyClass {
public $property = 'Hello World!';
public function MyMethod()
{
call_user_func(array($this, 'myCallbackMethod'));
}
public function MyCallbackMethod()
{
echo $this->property;
}
}
?>Performance note: The callable type hint, like is_callable(), will trigger an autoload of the class if the value looks like a static method callback.When specifying a call back in array notation (ie. array($this, "myfunc") ) the method can be private if called from inside the class, but if you call it from outside you'll get a warning:
<?php
class mc {
public function go(array $arr) {
array_walk($arr, array($this, "walkIt"));
}
private function walkIt($val) {
echo $val . "<br />";
}
public function export() {
return array($this, 'walkIt');
}
}
$data = array(1,2,3,4);
$m = new mc;
$m->go($data); // valid
array_walk($data, $m->export()); // will generate warning
?>
Output:
1<br />2<br />3<br />4<br />
Warning: array_walk() expects parameter 2 to be a valid callback, cannot access private method mc::walkIt() in /in/tfh7f on line 22A note on differences when calling callbacks as "variable functions" without the use of call_user_func() (e.g. "<?php $callback = 'printf'; $callback('Hello World!') ?>"):
- Using the name of a function as string has worked since at least 4.3.0
- Calling anonymous functions and invokable objects has worked since 5.3.0
- Using the array structure [$object, 'method'] has worked since 5.4.0
Note, however, that the following are not supported when calling callbacks as variable functions, even though they are supported by call_user_func():
- Calling static class methods via strings such as 'foo::doStuff'
- Calling parent method using the [$object, 'parent::method'] array structure
All of these cases are correctly recognized as callbacks by the 'callable' type hint, however. Thus, the following code will produce an error "Fatal error: Call to undefined function foo::doStuff() in /tmp/code.php on line 4":
<?php
class foo {
static function callIt(callable $callback) {
$callback();
}
static function doStuff() {
echo "Hello World!";
}
}
foo::callIt('foo::doStuff');
?>
The code would work fine, if we replaced the '$callback()' with 'call_user_func($callback)' or if we used the array ['foo', 'doStuff'] as the callback instead.You can use 'self::methodName' as a callable, but this is dangerous. Consider this example:
<?php
class Foo {
public static function doAwesomeThings() {
FunctionCaller::callIt('self::someAwesomeMethod');
}
public static function someAwesomeMethod() {
// fantastic code goes here.
}
}
class FunctionCaller {
public static function callIt(callable $func) {
call_user_func($func);
}
}
Foo::doAwesomeThings();
?>
This results in an error:
Warning: class 'FunctionCaller' does not have a method 'someAwesomeMethod'.
For this reason you should always use the full class name:
<?php
FunctionCaller::callIt('Foo::someAwesomeMethod');
?>
I believe this is because there is no way for FunctionCaller to know that the string 'self' at one point referred to to `Foo`.you can pass an object as a callable if its class defines the __invoke() magic method..I needed a function that would determine the type of callable being passed, and, eventually,
normalized it to some extent. Here's what I came up with:
<?php
/**
* The callable types and normalizations are given in the table below:
*
* Callable | Normalization | Type
* ---------------------------------+---------------------------------+--------------
* function (...) use (...) {...} | function (...) use (...) {...} | 'closure'
* $object | $object | 'invocable'
* "function" | "function" | 'function'
* "class::method" | ["class", "method"] | 'static'
* ["class", "parent::method"] | ["parent of class", "method"] | 'static'
* ["class", "self::method"] | ["class", "method"] | 'static'
* ["class", "method"] | ["class", "method"] | 'static'
* [$object, "parent::method"] | [$object, "parent::method"] | 'object'
* [$object, "self::method"] | [$object, "method"] | 'object'
* [$object, "method"] | [$object, "method"] | 'object'
* ---------------------------------+---------------------------------+--------------
* other callable | idem | 'unknown'
* ---------------------------------+---------------------------------+--------------
* not a callable | null | false
*
* If the "strict" parameter is set to true, additional checks are
* performed, in particular:
* - when a callable string of the form "class::method" or a callable array
* of the form ["class", "method"] is given, the method must be a static one,
* - when a callable array of the form [$object, "method"] is given, the
* method must be a non-static one.
*
*/
function callableType($callable, $strict = true, callable& $norm = null) {
if (!is_callable($callable)) {
switch (true) {
case is_object($callable):
$norm = $callable;
return 'Closure' === get_class($callable) ? 'closure' : 'invocable';
case is_string($callable):
$m = null;
if (preg_match('~^(?<class>[a-z_][a-z0-9_]*)::(?<method>[a-z_][a-z0-9_]*)$~i', $callable, $m)) {
list($left, $right) = [$m['class'], $m['method']];
if (!$strict || (new \ReflectionMethod($left, $right))->isStatic()) {
$norm = [$left, $right];
return 'static';
}
} else {
$norm = $callable;
return 'function';
}
break;
case is_array($callable):
$m = null;
if (preg_match('~^(:?(?<reference>self|parent)::)?(?<method>[a-z_][a-z0-9_]*)$~i', $callable[1], $m)) {
if (is_string($callable[0])) {
if ('parent' === strtolower($m['reference'])) {
list($left, $right) = [get_parent_class($callable[0]), $m['method']];
} else {
list($left, $right) = [$callable[0], $m['method']];
}
if (!$strict || (new \ReflectionMethod($left, $right))->isStatic()) {
$norm = [$left, $right];
return 'static';
}
} else {
if ('self' === strtolower($m['reference'])) {
list($left, $right) = [$callable[0], $m['method']];
} else {
list($left, $right) = $callable;
}
if (!$strict || !(new \ReflectionMethod($left, $right))->isStatic()) {
$norm = [$left, $right];
return 'object';
}
}
}
break;
}
$norm = $callable;
return 'unknown';
}
$norm = null;
return false;
}
?>
Hope someone else finds it useful.When trying to make a callable from a function name located in a namespace, you MUST give the fully qualified function name (regardless of the current namespace or use statements).
<?php
namespace MyNamespace;
function doSomethingFancy($arg1)
{
// do something...
}
$values = [1, 2, 3];
array_map('doSomethingFancy', $values);
// array_map() expects parameter 1 to be a valid callback, function 'doSomethingFancy' not found or invalid function name
array_map('MyNamespace\doSomethingFancy', $values);
// => [..., ..., ...]If you pass a callable method to a function with a callable type declaration, the error message is misleading:
<?php
class X {
protected function foo(): void {}
}
function bar(callable $c) {}
$x = new X;
$c = [$x, 'foo'];
bar($c);
?>
Error message will be something like "Argument #1 ($c) must be of type callable, array given" while the actual problem here is only the visibility of method "foo". All you need to do is changing it to public (or use a different approach, e.g. with a Closure).I tried many possible ways of calling functions by function name directly and assigned to a variable on 3v4l. Not mentioned yet, it is possible to use an array as a caller, at least since PHP 7.1.25. The following script contains all the information I gained:
<?php
// Call function via function name:
// Basics:
// A function can also be called by using its string name:
function callbackFunc() {
echo 'Hello World';
}
'callbackFunc'(); // Hello World
// A function can also be called if its name is assigned to a variable:
function callbackFunc() {
echo 'Hello World';
}
$funcName = 'callbackFunc';
$funcName(); // Hello World
// Static class method:
// It is also possible to call a public static class method via 'ClassName::functioName' notation:
class A {
public static function callbackMethod() {
echo "Hello World\n";
}
}
'A::callbackMethod'(); // Hello World
$funcName = 'A::callbackMethod';
$funcName(); // Hello World
// Non static class method:
// It is also possible to call non static class methods by creating an array which first element is the object the method should be called on and the second element is the non static method to be called. The array can directly be used as a caller:
class A {
private $prop = "Hello World\n";
public function callbackMethod() {
echo $this->prop;
}
}
$a = new A;
[$a, 'callbackMethod']();
$funcCallArr = [$a, 'callbackMethod'];
$funcCallArr();
// Of course this also works inside the class with '$this':
class A {
private function privCallback() {
echo 'Private';
}
public function privCallbackCaller($funcName) {
[$this, $funcName]();
}
}
(new A)->privCallbackCaller('privCallback'); // Private
?>@edanschwartz at gmail dot com
You can use ::class property to always indicate the class you're in when using static methods:
<?php
class Foo {
public static function doAwesomeThings() {
FunctionCaller::callIt(self::class . '::someAwesomeMethod');
}
public static function someAwesomeMethod() {
// fantastic code goes here.
}
}
class FunctionCaller {
public static function callIt(callable $func) {
call_user_func($func);
}
}
Foo::doAwesomeThings();
?>Having read this line in the manual above,
"A method of an instantiated object is passed as an array containing an object at index 0 and the method name at index 1. Accessing protected and private methods from within a class is allowed."
I decided to do some testing to see if I could access private methods using the call_user_func methods. Thankfully not, but for completeness here is my test which also covers using static and object contexts
<?php
class foo {
public static $isInstance = false;
public function __construct() {
self::$isInstance = true;
}
public function bar() {
var_dump(self::$isInstance);
echo __METHOD__;
}
private function baz() {
var_dump(self::$isInstance);
echo __METHOD__;
}
public function qux() {
$this->baz();
}
public function quux() {
self::baz();
}
}
call_user_func(['foo','bar']); //fase, foo:bar
call_user_func(['foo','baz']); //warning, cannot access private method
call_user_func(['foo','quux']); //false, foo::baz
call_user_func(['foo','qux']); //fatal, Using $this when not in object context
$foo = new foo;
call_user_func([$foo,'bar']); //true, foo::bar
call_user_func([$foo,'baz']); //warning, cannot access private method
call_user_func([$foo,'qux']); //true, foo::baz
call_user_func(['foo','bar']); //true, foo::bar (static call, yet $isInstance is true)
?>