如何按任何顺序使用PHP功能或方法参数

Question

，说我用这样的方法定义了类：

class Test {
    public function doStuff($a, $b, $c) {
    // -- Do stuff --
    }
}

可以使用此方法，但以不同的顺序进行参数，例如：

$test = new Test();
$test->doStuff($b, $c, $a);

他们的名字相同，但订单不同。

我看到Symfony2可以使用其调度程序来完成，您可以按照所需的任何顺序使用参数。链接：Symfony2控制器可以做到

问题是，如何使这项工作？Symfony2如何调用适当的动作控制器，然后可以按照您喜欢的任何顺序接受参数？

编辑：我不能使用数组，而且我确实知道PHP不使用名为参数。但是Symfony2设法以某种方式进行。

Answer 1

我认为您正在误解Symfony在说什么。您不能以任何顺序将论点传递给控制器行动，必须按特定顺序进行。但是，他们正在做的是动态的，但是弄清楚您的路由参数在函数定义内部的顺序。

例如，我们定义了一条路线：

pattern:      /hello/{first_name}/{last_name}
defaults:     { _controller: AcmeHelloBundle:Hello:index, color: green }

在路线中，参数命名为 first_name， last_name和 color。

他们在说的是，您在操作中使用什么顺序都没关系。

以下每个都是等效的：

public function indexAction($first_name, $last_name, $color) {...}
public function indexAction($color, $last_name, $first_name) {...}
public function indexAction($last_name, $color, $first_name) {...}

由于您的参数与路线中的参数相同，因此Symfony根据您的定义来弄清楚参数的正确顺序是什么。

如果您要手动致电以下操作：

public function indexAction($first_name, $last_name, $color)

然后，参数仍然必须以 $first_name, $last_name, $color的速度传递，而不是按任何其他顺序传递。使用不同的顺序只会将错误的值与参数相关联。Symfony只是不在乎您定义了什么订单，因为它确定了顺序，因为您的路由参数必须与您的方法参数相同。

希望清除混乱。

Answer 2

Sable Foste的想法启发了我。

您可以使用另一个参数指定顺序，然后使用变量变量：

function test($order, $_a, $_b, $_c){
  $order = explode(';', $order);
  ${$order[0]} = $_a;
  ${$order[1]} = $_b;
  ${$order[2]} = $_c;
  echo "a = $a; b = $b; c = $c<br>";
}

test('a;b;c', 'a', 'b', 'c');
test('b;a;c', 'b', 'a', 'c');

但是，认真的，为什么不能使用数组？这是最好的方法。

---

update ：我写了这篇文章。我一定很无聊。

现在我感到肮脏。

class FuncCaller{
    var $func;
    var $order_wanted;
    var $num_args_wanted;
    function FuncCaller( $func, $order ){
        $this->func = $func;
        if( is_set($order) ){
            // First version: receives string declaring parameters
            // We flip the order_wanted array so it maps name => index
            $this->order_wanted = array_flip( explode(';', $order) );  
            $this->num_args_wanted = count($this->order_wanted);
        } else {
            // Second version: we can do better, using reflection
            $func_reflection = new ReflectionFunction($this->func);
            $params = $func_reflection->getParameters();
            $this->num_args_wanted = func_reflection->getNumberOfParameters();
            $this->order_wanted = [];
            foreach( $params as $idx => $param_reflection ){
                $this->order_wanted[ $param_reflection->getName() ] = $idx;
            }
        }
    }

    function call(){
        if( func_num_args() <= 1 ){
            // Call without arguments
            return $this->func();
        }
        else if( func_num_args() == $this->num_args_wanted ){
            // order argument not present. Assume order is same as func signature
            $args = func_get_args();
            return call_user_func_array( $this->func, $args );
        }
        else {
            // @TODO: verify correct arguments were given
            $args_given = func_get_args();
            $order_given = explode( ';', array_shift($args_given) );
            $order_given = array_flip( $order_given );  // Map name to index
            $args_for_call = array();
            foreach( $this->order_wanted as $param_name => $idx ){
                $idx_given = $order_given[$param_name];
                $val = $args_given[ $idx_given ];
                $args_for_call[$idx] = $val;
            }
            return call_user_func_array( $this->func, $args_for_call );
        }
    }
    // This should allow calling the FuncCaller object as a function,        
    // but it wasn't working for me for some reason
    function __invoke(){
        $args = func_get_args();
        return call_user_func( $this->call, $args );
    }
}

// Let's create a function for testing:
function test( $first, $second, $third ){
    $first  = var_export($first , TRUE);
    $second = var_export($second, TRUE);
    $third  = var_export($third , TRUE);
    echo "Called test( $first, $second, $third );<br>";
}
// Now we test the first version: order of arguments is specified
$caller = new FuncCaller( test, '1st;2nd;3rd' );
$caller->call(1, 2, 3);
$caller->call('3rd;1st;2nd', 'c', 'a', 'b');
$caller->call('2nd;3rd;1st', 'Two', 'Three', 'One');
$caller->call('3rd;2nd;1st', 'Go!', 'Get Set...', 'Get Ready...');

echo "<br>";
// Now we test the second version: order of arguments is acquired by reflection
// Note we you won't be able to rename arguments this way, as we did above
$reflection_caller = new FuncCaller( test ); 
$reflection_caller->call(1, 2, 3);
$reflection_caller->call('third;first;second', 'c', 'a', 'b');
$reflection_caller->call('second;third;first', 'Two', 'Three', 'One');
$reflection_caller->call('third;second;first', 'Go!', 'Get Set...', 'Get Ready...');

Answer 3

否，但是您可以用不同订单的方法超载。或者，您可以尝试以反射或智能猜测参数来进行。我怀疑您可以提出一个优雅的解决方案，该解决方案适用于所有功能。

Answer 4

我有一种感觉，他们使用反射来检查调解器动作函数的声明；然后，他们以正确的顺序进行函数调用。

看看http://www.php.net/manual/en/class.refleflectionparameter.php。它具有getName和getPosition。

Answer 5

为什么不添加第四变量$ d，将传入顺序定义为函数。

class Test {
    public function doStuff($d, $a, $b, $c) {
      $v=explode(',', $d);
      foreach($v as $key => $value){
        switch ($value){
           case 'a':
             $aa = $v[a];
             break;
           case 'b':
             $bb = $v[b];
             break;
           case 'a':
             $cc = $v[c];
             break;
          }
         echo "a is $aa, b is $bb, c is $cc"; //output  
      }
// -- Do stuff --
}
}
$d= "b,c,a"; // the order of the variables
$test = new Test();
$test->doStuff($d, $b, $c, $a);