pourquoi devrait-on préférer call_user_func_array plus régulier de l'appel de la fonction?

Dans le scénario régulière méthode d'appel échouera mais call_user_func_array ne va pas ?

Si vous ne savez pas à l'avance combien d'arguments que vous allez passer à votre fonction, il serait conseillé d'utiliser call_user_func_array(); la seule alternative est une switch déclaration ou un tas de conditions pour accomplir un sous-ensemble prédéfini de possibilités.

Un autre scénario est celui où la fonction est appelée n'est pas connu à l'avance, par exemple array($obj, 'method'); c'est aussi là que vous pouvez utiliser call_user_func().

$fn = array($obj, 'method');
$args = [1, 2, 3];
call_user_func_array($fn, $args);

Notez que l'utilisation de call_user_func_* fonctions ne peuvent pas être utilisés pour appeler des méthodes privées ou protégées.

L'alternative à tout cela, c'est de faire de vos fonctions accepter un tableau comme seul argument:

myfn([1, 2, 3]);

Cependant, ce qui élimine la possibilité de type de l'indice de chaque argument dans votre déclaration de fonction et est généralement considéré comme une odeur de code.

call_user_func_array effectue "uncurrying", qui est le contraire de "nourrissage".

Suivantes s'applique à tous les PHP "callables" (du nom des fonctions, des fermetures, des méthodes, des __invoke, etc.), donc, pour des raisons de simplicité nous allons ignorer les différences et de se concentrer uniquement sur les fermetures.

Si nous voulons accepter de multiples arguments, PHP nous permet de le faire avec 3 différentes Api. La méthode habituelle est: est-ce

$usual = function($a, $b, $c, $d) {
             return $a + $b + $c + $d;
         };
$result = $usual(10, 20, 30, 40);  //$result == 100

Une autre façon est appelé au cari forme:

$curried = function($a) {
               return function($b) use ($a) {
                          return function($c) use ($a, $b) {
                                     return function($d) use ($a, $b, $c) {
                                                return $a + $b + $c + $d;
                                            };
                                 };
                      };
           };
$result = call_user_func(
              call_user_func(
                  call_user_func(
                      $curried(10),
                      20),
                  30),
              40);  //$result == 100

L'avantage est que tout le curry de fonctions peuvent être appelées de la même manière: leur donner un argument.

Si plusieurs arguments sont requis, en plus des fonctions curryfiées sont retournés, qui "se souvenir de" l'argumentation précédente. Cela nous permet de passer des arguments maintenant et le reste plus tard.

Il y a quelques problèmes:

• Clairement c'est très fastidieux à écrire et appeler des fonctions de cette façon.
• Si nous fournir des fonctions curryfiées, ils vont être difficile à chaque fois que leur "mémoire" de la capacité n'est pas nécessaire.
• Si nous nous appuyons sur la "mémoire" de la capacité de fonctions curryfiées, nous allons être déçus quand d'autres personnes de code n'a pas les fournir.

Nous pouvons résoudre tous ces problèmes en utilisant un fonction de conversion (avis de non responsabilité: c'est mon blog). Ceci nous permet d'écrire et d'appeler de ses fonctions de la manière habituelle, mais leur donne même la "mémoire" de la capacité, comme s'ils étaient au curry:

$curried = curry(function($a, $b, $c, $d) {
                     return $a + $b + $c + $d;
                 });
$result1 = $curried(10, 20, 30, 40);  //$result1 = 100
$result2 = call_user_func($curried(10, 20), 30, 40); //$result2 = 100

La troisième façon est appelée uncurried et prend tous ses arguments dans un:

$uncurried = function($args) {
                 return $args[0] + $args[1] + $args[2] + $args[3];
             };
$result = $uncurried([10, 20, 30, 40]);  //$result == 100

Tout comme avec des fonctions curryfiées, uncurried fonctions peuvent tous être appelée avec un argument, bien que cette fois c'est un tableau. Nous avons toujours confrontés aux mêmes problèmes de compatibilité comme le curry de fonctions: si l'on choisit d'utiliser uncurried fonctions, nous ne pouvons pas compter sur tout le monde en choisissant la même. Donc nous avons besoin également d'une fonction de conversion pour uncurrying. C'est ce que call_user_func_array n':

$uncurried = function($args) use ($usual) {
                 return call_user_func_array($usual, $args);
             };
$result1 = $usual(10, 20, 30, 40);  //$result1 = 100
$result2 = $uncurried([10, 20, 30, 40]); //$result2 = 100

Fait intéressant, nous pouvons nous débarrasser de ce surcroît d' function($args) wrapper (un processus connu sous le nom "eta-réduction") par nourrissage call_user_func_array:

$uncurried = curry('call_user_func_array', $usual);

$result = $uncurried([10, 20, 30, 40]); //$result == 100

Malheureusement call_user_func_array n'est pas aussi intelligent que curry; il n'est pas de convertir automatiquement entre les deux. Nous pouvons écrire notre propre uncurry fonction qui a cette capacité:

function uncurry($f)
{
    return function($args) use ($f) {
               return call_user_func_array(
                          $f,
                          (count(func_get_args()) > 1)? func_get_args()
                                                      : $args);
           };
}

$uncurried = uncurry($usual);
$result1 = $uncurried(10, 20, 30, 40); //$result1 == 100
$result2 = $uncurried([10, 20, 30, 40]); //$result2 == 100

Ces fonctions de conversion de montrer que PHP "habitués" à la manière de définir des fonctions est en fait redondante: si nous avons remplacé PHP "habituel" fonctions "smart" au curry ou uncurried ceux, beaucoup de code de travail. Si nous faisions cela, il est préférable de curry tout et de manière sélective uncurry que nécessaire, car c'est plus facile que d'aller dans l'autre sens.

Malheureusement, certaines choses qui s'attendent à un nombre variable d'arguments à l'aide de func_get_args allait se briser, ainsi que des fonctions par défaut des valeurs d'argument.

Fait intéressant, les valeurs par défaut sont juste une forme particulière de nourrissage. On pourrait surtout faire sans eux, si nous mettons ces arguments première au lieu du dernier, et a fourni un tas d'autres définitions qui curry dans les paramètres par défaut. Par exemple:

$defaults = function($a, $b, $c = 30, $d = 40) {
                return $a + $b + $c + $d;
            };
$def1 = $defaults(10, 20, 30, 40);  //$def1 == 100
$def2 = $defaults(10, 20, 30);      //$def2 == 100
$def3 = $defaults(10, 20);          //$def3 == 100

$curried = function($d, $c, $a, $b) {
               return $a + $b + $c + $d;
           };
$curriedD  = $curried(40);
$curriedDC = $curriedD(30);

$cur1 = $curried(10, 20, 30, 40);  //$cur1 == 100
$cur2 = $curriedD(10, 20, 30);     //$cur2 == 100
$cur3 = $curriedDC(10, 20);        //$cur3 == 100

<?php

class Demo {

    public function function1() {
        echo 'in function 1';
    }
}

$obj = new Demo();

$function_list = get_class_methods('Demo');

print_r($function_list);  //Array ( [0] => function1 )

call_user_func_array(array($obj, $function_list[0]), array()); 

//Output => in function 1

?>