Question

假设我用这样的方法定义类：

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

是否可以使用此方法，但参数的顺序不同，如下所示：

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

他们会有相同的名字，但只是顺序不同。

我看到Symfony2可以使用其调度程序执行此操作，您可以按任何顺序使用参数。链接：Symfony2 controller can do it

问题是，如何使这项工作？ 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的想法激发了我的灵感。

您可以使用其他参数指定顺序，然后使用variable variables：

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');

但严重的是，你为什么不能使用阵列？这是最好的方式。

更新：我写了这个。我一定很无聊。

现在我觉得很脏。

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.reflectionparameter.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);

如何以任何顺序使用PHP函数或方法参数？

5 个答案: