What scenario requires use of call_user_func() in php

Question

I dont understand the function, call_user_func() in the sense that i get how it works but I'm not sure why its required or in what context to use it in php. As far as I'm concerned why not just call the function instead of calling a function with a function? Thnx!

Answer 1

call_user_func gives PHP the ability to treat methods and functions as quasi first-class citizens. In functional languages like javascript there is no need for these special tools per-se because a function is an object that happens to be callable.

PHP is getting closer to having this sort of notion though, especially with the closure support that came along with PHP5.3. Take a look at the comment I put under @deceze's answer. There are some other tools (namely variable functions, reflection and now closures) that offer the same basic functionality.

The most notable thing about call_user_func though is how it allows you to treat global functions, static classes and objects with a uniform interface. It's probably the closest thing they have to a single interface to invoke functions no matter how they're implemented. Internally the PHP core group of developers is working to homogenize some sort of a 'callable' or 'invokable' interface for the language, I'm sure we'll see a clean offering in PHP5.4 or the next major release.

Answer 2

Named functions, anonymous functions, static methods, instance methods and objects with an "__invoke" method are collectively known as 'callables'. If I have a callable it should be possible to call it by placing parentheses afterwards "()" (I'll assume it takes no arguments). This works when our callable is stored in a variable, for example:

$f();  // Call $f

However, what if I store a callable in an object property?

$obj = new stdClass;
$obj->my_func = function() {};
$obj->my_func();  // Error: stdClass does not have a "my_func" method

The problem is that PHP's parser is getting confused because the code is ambiguous, it could mean calling a callable property or calling a method. PHP chooses to always treat this kind of code as a method call, so we cannot call callable properties this way. This is why we need 'call_user_func':

call_user_func($obj->my_func); // Calls $obj->my_func

There are other times when PHP doesn't understand the normal parentheses syntax; for example, PHP currently (5.5) doesn't know how to call the return value of another callable:

get_a_callable()();  // Parse error, unexpected "("
call_user_func(get_a_callable());  // Calls the return value of get_a_callable

It's also not currently possible to call a function definion directly, which is useful to work around PHP's lack of "let" statements, for example:

function($x) { echo $x . $x; }('hello');  // Parse error, unexpected "("
call_user_func(function($x) { echo $x . $x; }, 'hello'); // Calls the function

There are also times where it's useful to have function calls /reified/ as the 'call_user_func' function. For example, when using higher-order functions like array_map:

$funcs = [function() { return 'hello'; },
          function() { return 'world'; }];
array_map('call_user_func', $funcs);  // ['hello', 'world']

It's also useful when we don't know how many parameters will be needed, ie. we can't substitute our own "function($f, $x, $y, ...) { return $f($x, $y, ...); }".

One particularly nice definition is partial application, which only takes a few lines thanks to call_user_func and call_user_func_array:

function partial() {
  $args1 = func_get_args();  // $f, $a, $b, $c, ...
  return function() use ($args1) {
    // Returns $f($a, $b, $c, ..., $d, $e, $f, ...)
    $args2 = func_get_args();  // $d, $e, $f, ...
    return call_user_func_array('call_user_func',
                                array_merge($args1, $args2));
  };
}

Answer 3

I've had a couple situations where this was very necessary. For example, when I was creating a project that allowed a user to construct parts of a programming language, the system would wrap the "tag" definition in a function before running it for security reasons. However, in doing this, I can't simply call those functions, because I don't know when I need to call them, or even what the names would be. Enter call_user_func()...

So, I'm sure you're confused right now. Let me explain. What my system did, was take some XML, and convert it into PHP/HTML/JS with PHP. This allowed for rapid creation of GUIs (which was the goal). Take this XML for example:

<window id="login-win" title="Access Restricted" width="310" height="186" layout="accordion" layoutConfig="animate:true">
    <panel id="login-panel" title="User Login">
        <form id="login-form" title="Credentials">
            <textbox id="login-uname" label="Username"/>
            <password id="login-pass" label="Password"/>
            <submit text="Login"/>
        </form>
    </panel>
    <panel id="login-register" title="Register">
        Nothing, you can't register!
    </panel>
</window>

Each XML tag would be read, then fed into it's corresponding PHP function. That function would determine what to do for that 1 tag. In order to pull this off, I had files each named after the tag it handled. So, for example, the tag's file was "submit.php". This file's contents would get wrapped in a generated function, something like:

function tag_submit($variables, $parent, $children){

    // deal with the data, then echo what is needed

}

This function's name would be stored in an array, with it's associated tag name, with the rest of the generated functions. This makes it so the function is generated once, and only created when needed, saving memory, since I would do a if(func_exists()) call to determine if I needed it or not.

However, since this is all dynamic, and the user may want to add in a new tag, for say, a < date > tag, I needed to use call_user_func() to get things to work. I can't hard-code a function call if I don't know what the name is.

Hope that all made sense. Basically, yes, it is a rarely used function, but it is still very very useful.