6

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

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

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

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

它们将具有相同的名称，但顺序不同。

我看到 Symfony2 可以使用它的调度程序来做到这一点，你可以按照你想要的任何顺序使用参数。链接：Symfony2 控制器可以做到

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

编辑：我不能使用数组，而且我知道 php 不使用命名参数。但不知何故 Symfony2 设法做到了。

4

5 回答 5

8

我认为您误解了 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按 as而不是以任何其他顺序传入。使用不同的顺序只会将错误的值与参数相关联。Symfony 只是不关心您定义函数的顺序，因为它决定了顺序，因为您的路由参数必须与您的方法参数命名相同。

希望这能消除混乱。

于 2012-10-19T20:16:35.157 回答
4

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

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

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

现在我觉得很脏。

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...');
于 2012-10-19T21:55:13.730 回答
2

不，但是您可以重载具有不同顺序的方法。或者你可以尝试通过反射或智能猜测参数来做到这一点。我怀疑你能想出一个适用于所有功能的优雅解决方案。

于 2012-10-19T20:09:32.960 回答
2

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

看看http://www.php.net/manual/en/class.reflectionparameter.php。它有一个 getName 和 getPosition。

于 2012-10-20T12:56:04.773 回答
1

为什么不添加第四个变量 $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);
于 2012-10-19T20:23:54.693 回答