PHP call_user_func vs. solo chiamata di funzione

Sono sicuro che ci sia una spiegazione molto semplice per questo. Qual è la differenza tra questo:

function barber($type){
    echo "You wanted a $type haircut, no problem\n";
}
call_user_func('barber', "mushroom");
call_user_func('barber', "shave");

... e questo (e quali sono i vantaggi?):

function barber($type){
    echo "You wanted a $type haircut, no problem\n";
}
barber('mushroom');
barber('shave');

Usa sempre il nome effettivo della funzione quando lo conosci.

call_user_func serve per chiamare funzioni di cui non si conosce il nome in anticipo, ma è molto meno efficiente poiché il programma deve cercare la funzione in fase di esecuzione.

Sebbene tu possa chiamare i nomi delle funzioni delle variabili in questo modo:

function printIt($str) { print($str); }

$funcname = 'printIt';
$funcname('Hello world!');

ci sono casi in cui non sai quanti argomenti stai passando. Considera quanto segue:

function someFunc() {
  $args = func_get_args();
  // do something
}

call_user_func_array('someFunc',array('one','two','three'));

È anche utile per chiamare rispettivamente metodi statici e oggetto:

call_user_func(array('someClass','someFunc'),$arg);
call_user_func(array($myObj,'someFunc'),$arg);

l' call_user_funcopzione è lì così puoi fare cose come:

$dynamicFunctionName = "barber";

call_user_func($dynamicFunctionName, 'mushroom');

dove la dynamicFunctionNamestringa potrebbe essere più eccitante e generata in fase di esecuzione. Non dovresti usare call_user_func a meno che non sia necessario, perché è più lento.

Immagino sia utile per chiamare una funzione di cui non conosci il nome in anticipo ... Qualcosa come:

switch($value):
{
  case 7:
  $func = 'run';
  break;
  default:
  $func = 'stop';
  break;
}

call_user_func($func, 'stuff');

Con PHP 7 puoi usare ovunque la sintassi delle funzioni variabili più piacevole. Funziona con funzioni statiche / di istanza e può richiedere un array di parametri. Maggiori informazioni su https://trowski.com/2015/06/20/php-callable-paradox

$ret = $callable(...$params);

Non ci sono vantaggi nel chiamare la funzione in questo modo perché penso che fosse principalmente utilizzata per chiamare la funzione "utente" (come il plugin) perché la modifica del file core non è una buona opzione. qui ci sono sporchi esempi usati da Wordpress

<?php
/* 
* my_plugin.php
*/

function myLocation($content){
  return str_replace('@', 'world', $content);
}

function myName($content){
  return $content."Tasikmalaya";
}

add_filter('the_content', 'myLocation');
add_filter('the_content', 'myName');

?>

...

<?php
/*
* core.php
* read only
*/

$content = "hello @ my name is ";
$listFunc = array();

// store user function to array (in my_plugin.php)
function add_filter($fName, $funct)
{
  $listFunc[$fName]= $funct;
}

// execute list user defined function
function apply_filter($funct, $content)
{
  global $listFunc;

  if(isset($listFunc))
  {
    foreach($listFunc as $key => $value)
    {
      if($key == $funct)
      {
        $content = call_user_func($listFunc[$key], $content);
      }
    }
  }
  return $content;
}

function the_content()
{
  $content = apply_filter('the_content', $content);
  echo $content;
}

?>

....

<?php
require_once("core.php");
require_once("my_plugin.php");

the_content(); // hello world my name is Tasikmalaya
?>

produzione

hello world my name is Tasikmalaya

nel tuo primo esempio stai usando il nome della funzione che è una stringa. potrebbe provenire dall'esterno o essere determinato al volo. cioè, non sai quale funzione dovrà essere eseguita al momento della creazione del codice.

Quando si utilizzano gli spazi dei nomi, call_user_func () è l'unico modo per eseguire una funzione di cui non si conosce il nome in anticipo, ad esempio:

$function = '\Utilities\SearchTools::getCurrency';
call_user_func($function,'USA');

Se tutte le tue funzioni fossero nello stesso spazio dei nomi, non sarebbe un problema del genere, poiché potresti usare qualcosa del genere:

$function = 'getCurrency';
$function('USA');

Modifica: seguendo @Jannis dicendo che mi sbaglio ho fatto un po 'più di test e non ho avuto molta fortuna:

<?php
namespace Foo {

    class Bar {
        public static function getBar() {
            return 'Bar';
        }
    }
    echo "<h1>Bar: ".\Foo\Bar::getBar()."</h1>";
    // outputs 'Bar: Bar'
    $function = '\Foo\Bar::getBar';
    echo "<h1>Bar: ".$function()."</h1>";
    // outputs 'Fatal error: Call to undefined function \Foo\Bar::getBar()'
    $function = '\Foo\Bar\getBar';
    echo "<h1>Bar: ".$function()."</h1>";
    // outputs 'Fatal error: Call to undefined function \foo\Bar\getBar()'
}

Puoi vedere i risultati dell'output qui: https://3v4l.org/iBERh sembra che il secondo metodo funzioni per PHP 7 in poi, ma non PHP 5.6.