When to use call_user_func_array

David Sklar addressed the question of when to use call_user_func_array in his PHP Cookbook. So, to focus on one comment of the OP:

"...don't you always need to know the arguments if they are to be used in a function?"

Here's an instance where call_user_func() can come in handy:

<?php

function Test(){
  $args = func_get_args();
  call_user_func_array("printf",$args);
}

Test("Candidates 2014: %s %s %s %s\n","Tom","Debbie","Harry", "Sally");
Test("Candidates 2015: %s %s\n","Bob","Sam","Sarah");

See live code

With the pair of call_user_func_array() and func_get_args(), the user-defined function Test() can take a variable number of arguments.

Also, useful for aggregating methods (see PHP Cookbook p208-210) as the following simplified example demonstrates:

<?php
class Address {
   protected $city;

   public function getCity() {
      return $this->city;
   }
   public function setCity($city) {
      $this->city=$city;
   }
}

class Person {
     protected $name="Tester";
     protected $address;

     public function __construct() {
            $this->address = new Address;
     }
     public function getName(){
            return $this->name;
     }
    public function __call($method, $args){
           if (method_exists($this->address,$method)) {
                return call_user_func_array( array($this->address,$method),$args);
           }
    }
}

  $sharbear = new Person;
  echo $sharbear->setCity("Baltimore");
  echo "Name: ",$sharbear->getName(),"\n";
  echo "City: ",$sharbear->getCity();

See live code

Addendum

Since PHP 5.6, PHP supports variadic functions and argument unpacking, so call_user_func() and func_get_args() may be replaced with respect to variable arguments as follows:

<?php

function Test(...$args){

   printf(...$args);
}
$namesT = ["Timmy","Teddy","Theo","Tad"];
$namesB = ["Bobby","Bill","Brad"];

Test("T Names: %s %s %s %s\n",...$namesT);
Test("B Names: %s %s %s\n",...$namesB);

See live code

<!-- begin snippet: js hide: false console: true babel: false -->

<pre>
I use call_user_func_array when I need to call a function or php function from my ajax enabled page. 

eg.
in html and javascript:

<form id='my-form'>

<input id='name' value='Wong, Billy'>
<input id='age' value='50'>

<a href='javascript;' onClick="xjx.query('helloWorld', $('#name').val(), $('#age').val())">Show name and age</a>

<a href='javascript;' onClick="xjx.query('showName', $('#name').val())">Show name</a>

<a href='javascript;' onClick="xjx.query('showAge', $('#age').val())">Show age</a>

<a href='javascript;' onClick="xjx.post('#my-form', 'showPost', 'live long and prosper')">Show age</a>

</form>

xjx.query and xjx.post, personal javascript functions of mine will then format and submit to the php page via ajax

in php
$method = $_POST['method'];
$args = $_POST['args'];

call_user_func_array($method, $args)

function helloWorld($name, $age) {
    ....
}

function showName($name) {
    ....
}

function showAge($age) {
    ....
}

function showPost($f, $message) {
   print_r($f);
   echo $message;
}

my libs are found in github with xjx as the project name
</pre>

let say we have couple of classes

class Request 
{
    private $req;

    public function __construct($req)
    {
        $this->req = $req;
    }

    public function __call($name, $arg)
    {
        return \call_user_func_array(array($this->req,$name), $arg);
    }
}

class Get 
{
    public function load($url)
    {
        // fire an http request
    }
}

class Post 
{
    public function load($url)
    {
        // fire an http request
    }

    public function attachHeader($header=[])
    {
        // attach an header to the request
    }
}

$request_1 = new Request(new Get());
$request_1->load($url);

$request_2 = new Request(new Post());
$request_2->attachHeader($header_data);
$request_2->load($url);

here you can see we can call the attachHeader() method by using of call_user_func_array() without any problem.

i hope it will help

I find it useful when working with variadic functions.

// a variadic function
function implode_this_array( $label, ...$items ) {
    echo $label . implode( '; ', $items );
}

// another variadic function
function some_other_function_elsewhere( ...$args ) {

    // do something here
    // ...
    // do something else here
    // ...

    call_user_func_array( 'implode_this_array', $args );

    // or the equivalent's PHP 7.4+ with the spread operator:
    // call_user_func_array( 'implode_this_array', [ ...$args ] );
}

some_other_function_elsewhere( 'I got this = ', 'foo', 'bar' );

Will output:

I got this = foo; bar

Now that I read this, perhaps it doesn't excel in readability. But it has its use sometimes.

edit: sorry, maybe a bit of a duplicate of another answer.