What does the keyword "callable" do in PHP

user_10774832 0
Viewed 13986

To be more exact, the "callable" used in function declaration arguments. like the one below.

function post($pattern, callable $handler) {
    $this->routes['post'][$pattern] = $handler;
    return $this;
}

How does it benefit us?

why and how do we use it?

Maybe this is very basic for you, however, I've tried searching for it and I was getting no answers. at least, nothing I could understand.

Hoping for a for-dummies answer. I'm new to coding... XD

Edit: Here's a link to where I copied the above piece of code from: link

type-declaration function-declaration type-hinting callable php
6 Answers

The callable type allows us to pass a callback function to the function that is being called. That is, callback function parameters allow the function being called to dynamically call code that we specify in the callable function parameter. This is useful because it allows us to pass dynamic code to be executed to a function.

For example, one might want to call a function and the function accepts a callback function called log, which would log data in a custom way that you want.

I hope that makes sense. For details, see this link.

user_48515650

It's a type hinting which tells us this function accepts the parameter $handler as a function, see this example to clarify things:

function helloWorld()
{
   echo 'Hello World!';
}
function handle(callable $fn)
{
   $fn(); // We know the parameter is callable then we execute the function.
}

handle('helloWorld'); // Outputs: Hello World!

It's a very simple example, But I hope it helps you understand the idea.

user_56386580

Here is example use of using a callable as a parameter.

The wait_do_linebreak function below will sleep for a given time, then call a function with the tailing parameters given, and then echo a line break.

...$params packs the tailing parameters into an array called $params. Here it's being used to proxy arguments into the callables.

At the end of the examples you'll see a native function that takes a callable as a parameter.

<?php

function wait_do_linebreak($time, callable $something, ...$params)
{
    sleep($time);
    call_user_func_array($something, $params);
    echo "\n";
}

function earth_greeting() {
    echo 'hello earth';
}

class Echo_Two
{
    public function __invoke($baz, $bat)
    {
        echo $baz, " ", $bat;
    }
}

class Eat_Static
{
    static function another()
    {
        echo 'Another example.';
    }
}

class Foo
{
    public function more()
    {
        echo 'And here is another one.';
    }
}

wait_do_linebreak(0, 'earth_greeting');
$my_echo = function($str) {
    echo $str;
};
wait_do_linebreak(0, $my_echo, 'hello');
wait_do_linebreak(0, function() {
    echo "I'm on top of the world.";
});
wait_do_linebreak(0, new Echo_Two, 'The', 'Earth');
wait_do_linebreak(0, ['Eat_Static', 'another']);
wait_do_linebreak(0, [new Foo, 'more']);

$array = [
    'jim',
    'bones',
    'spock'
];

$word_contains_o = function (string $str) {
    return strpos($str, 'o') !== false;
};
print_r(array_filter($array, $word_contains_o));

Output:

hello earth
hello
I'm on top of the world.
The Earth
Another example.
And here is another one.
Array
(
    [1] => bones
    [2] => spock
)
user_33927620

A callable (callback) function is a function that is called inside another function or used as a parameter of another function

// An example callback function
function my_callback_function() {
    echo 'hello world!';
}

// Type 1: Simple callback
call_user_func('my_callback_function');

There are some cases that your function is a template for other functions, in that case, you use parameters for the callable function.

for more information: http://php.net/manual/en/language.types.callable.php

user_107792040

Callable

callable is a php data type. It simply means anything which can be called i.e. a function type. If this function is a closure, static/regular method or something else doesn't matter as long as we can call the function.

Example:

//php callable type

$callback = function() {
    return "hello world!\n";
};

class MyClass {
    static function myCallbackMethod() {
        return "static method call \n";
    }

    public function cb()
    {
        return "method call \n";
    }

    public function __invoke() {
        return "invoke \n";
    }
}

$obj = new MyClass();

// Illustrative function
function soUseful (callable $callback) {
    echo $callback();
}

soUseful($callback);
soUseful(array($obj, 'cb')); // syntax for making  method callable
soUseful(array('MyClass', 'myCallbackMethod')); // syntax for making static method callable
soUseful($obj); // Object can be made callable via __invoke()
soUseful(fn() => "hi from closure \n"); // arrow fn

//Output
//hello world!
//method call
//static method call
//invoke
//hi from closure
user_80594590

Callable is a data-type.

note: You can always check whether your variables are of type "callable" by using the built-in is_callable function, giving your variable's handler as its argument.

The "callable" keyword seen in the code, is used for a "Type declaration", also known as "type hint" in PHP 5. this is used to specify which type of argument or parameter your functions or methods accept. this is done by simply putting the "type hint" or "Type declaration" (i.e. the name of the type, like in this case, "callable") before the parameter names.

Whenever using "type hints" or "Type declarations" for your function declarations (i.e. when you've specified which types are allowed/accepted), and you're calling them giving parameters of data-types other than those specified as acceptable, an error is generated.

note: also, class names can be used if you would like to make your function require > an object instantiated from a specific class < for its respective parameter

-

References:

php manual > type-declaration

php manual > callable type

-

I'm new to coding so please correct my mistakes :)

user_107748320
Related