Comment convertir une liste de paramètres d'une fonction PHP en un tableau associatif?

Question

Je souhaite convertir les arguments d'une fonction en un tableau associatif avec des clés égales aux noms de variable de paramètre et des valeurs égales à celles du paramètre.

PHP:

function my_function($a, $b, $c) {

    // <--- magic goes here to create the $params array

    var_dump($params['a'] === $a); // Should result in bool(true)
    var_dump($params['b'] === $b); // Should result in bool(true)
    var_dump($params['c'] === $c); // Should result in bool(true)
}

Comment puis-je faire cela?

Answer 1

Vous pouvez le faire en utilisant compact :

function myFunc($a, $b, $c) {
    $params = compact('a', 'b', 'c');
    // ...
}

Ou, get_defined_vars () vous donnera un tableau associatif de toutes les variables définies dans cette portée, ce qui fonctionnerait, mais je pense que cela pourrait aussi inclure $ _ POST , $ _GET , etc ...

Sinon, vous pouvez utiliser func_get_args pour obtenir la liste de tous les arguments passés à la fonction. Ce n'est pas associatif, car ce ne sont que les données qui sont transmises (c'est-à-dire qu'il n'y a pas de noms de variables). Cela vous permet également d’avoir un nombre quelconque d’arguments dans votre fonction.

Ou, spécifiez simplement un argument, qui est un tableau:

function myFunc($params) {

}

compact () semble être le plus proche de ce que vous cherchez après.

Answer 2

get_defined_vars () est ce dont vous avez besoin si aucun autre vars n'est défini avant son appel dans la fonction (vous pouvez faites-le en faisant la première chose que vous faites dans la fonction).

function my_function($a, $b, $c) {

    $params = get_defined_vars(); // <--- create the $params array

    var_dump($params['a'] === $a); // results in bool(true)
    var_dump($params['b'] === $b); // results in bool(true)
    var_dump($params['c'] === $c); // results in bool(true)
}

Answer 3

J'ai voté à la réponse de @ nickf mais voudrais ajouter que cette compact () est également un excellent moyen d'instancier un modèle à l'aide d'un ctor:

class User {
    public $email;
    public $password;
    public $firstName;
    public $lastName;

    public function __construct ( $email, $password, $firstName, $lastName )
    {
        foreach ( compact( array_keys( (array)$this )) as $k => $v )
            $this->$k = $v;
    }
}

Assurez-vous que les paramètres ont exactement la même orthographe que les champs.

Answer 4

Comme suggéré, mais non implémenté: vous pouvez utiliser Reflection pour rassembler les noms de paramètres, puis les associer aux valeurs:

function args_to_assoc_array($function, $args) {                                 
    if (false === strpos($function, '::')) {                                     
        $reflection = new ReflectionFunction($function);                         
    } else {                                                                     
        $reflection = new ReflectionMethod(...explode('::', $function));         
    }                                                                            
    $assoc = [];                                                                 
    foreach ($reflection->getParameters() as $i => $parameter) {                 
        $assoc[$parameter->getName()] = $args[$i];                               
    }                                                                            
    return $assoc;                                                               
}                                                                                

Vous pouvez ensuite appeler cela de la même manière, que ce soit dans une fonction ou une méthode:

function f($x, $y) { return args_to_assoc_array(__METHOD__, func_get_args()); }
class A {                                                                     
    function m($z) { return args_to_assoc_array(__METHOD__, func_get_args()); }
}                                                                             
var_dump(f(7, 2), (new A)->m(4));                                             

qui génère :

array(2) {
  ["x"]=>
  int(7)
  ["y"]=>
  int(2)
}
array(1) {
  ["z"]=>
  int(4)
}

Je ne l'ai pas chronométré, mais je soupçonne fortement que c'est beaucoup plus lent que d'utiliser compact .