PHP call_user_func vs juste appeler la fonction

Je suis sûr qu'il y a une explication très simple à cela. Quelle est la différence entre ceci:

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

... et ceci (et quels sont les avantages?):

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

Utilisez toujours le nom réel de la fonction lorsque vous le connaissez.

call_user_func est pour appeler des fonctions dont vous ne connaissez pas le nom à l'avance, mais c'est beaucoup moins efficace car le programme doit rechercher la fonction à l'exécution.

Bien que vous puissiez appeler les noms de fonctions variables de cette façon:

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

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

il y a des cas où vous ne savez pas combien d'arguments vous transmettez. Considérer ce qui suit:

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

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

C'est également pratique pour appeler des méthodes statiques et objet, respectivement:

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

l' call_user_funcoption est là pour que vous puissiez faire des choses comme:

$dynamicFunctionName = "barber";

call_user_func($dynamicFunctionName, 'mushroom');

où la dynamicFunctionNamechaîne pourrait être plus excitante et générée au moment de l'exécution. Vous ne devriez pas utiliser call_user_func sauf si vous devez le faire, car il est plus lent.

J'imagine que c'est utile pour appeler une fonction dont vous ne connaissez pas le nom à l'avance ... Quelque chose comme:

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

call_user_func($func, 'stuff');

Avec PHP 7, vous pouvez utiliser partout la meilleure syntaxe de fonction variable. Il fonctionne avec des fonctions statiques / d'instance et peut prendre un tableau de paramètres. Plus d'informations sur https://trowski.com/2015/06/20/php-callable-paradox

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

Il n'y a aucun avantage à appeler la fonction comme ça parce que je pense que c'était principalement utilisé pour appeler la fonction "utilisateur" (comme le plugin) parce que l'édition du fichier core n'est pas une bonne option. voici un exemple sale utilisé par 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
?>

production

hello world my name is Tasikmalaya

dans votre premier exemple, vous utilisez le nom de la fonction qui est une chaîne. il peut venir de l'extérieur ou être déterminé à la volée. c'est-à-dire que vous ne savez pas quelle fonction devra être exécutée au moment de la création du code.

Lors de l'utilisation d'espaces de noms, call_user_func () est le seul moyen d'exécuter une fonction dont vous ne connaissez pas le nom au préalable, par exemple:

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

Si toutes vos fonctions étaient dans le même espace de noms, alors ce ne serait pas un tel problème, car vous pourriez utiliser quelque chose comme ceci:

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

Edit: Après @Jannis disant que je me trompe, j'ai fait un peu plus de tests et je n'ai pas eu beaucoup de chance:

<?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()'
}

Vous pouvez voir les résultats de sortie ici: https://3v4l.org/iBERh il semble que la deuxième méthode fonctionne à partir de PHP 7, mais pas de PHP 5.6.