Cfrgtkky

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

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.

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.

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

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

)

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 :)