Question

假设我有一个函数/方法F（），它接受3个参数$ A，$ B和$ C定义为此。

function F($A,$B,$C){
  ...
}

假设我不想按顺序传递参数，而是可以这样打电话吗？

F($C=3,$A=1,$B=1);

而不是

F(1,2,3)

Answer 1

绝对不是。

你能够传递无序参数的一种方法是接受一个关联数组：

function F($params) {
   if(!is_array($params)) return false;
   //do something with $params['A'], etc...
}

然后你可以像这样调用它：

F(array('C' => 3, 'A' => 1, 'B' => 1));

Answer 2

PHP没有命名参数，所以简短的答案是否定的。我可以找到两种解决方案，虽然两者都不是那么棒。

您可以定义函数以将其参数作为数组，例如this：

function image($img) {
    $tag  = '<img src="' . $img['src'] . '" ';
    $tag .= 'alt="' . ($img['alt'] ? $img['alt'] : '') .'">';
    return $tag;
}

$image = image(array('src' => 'cow.png', 'alt' => 'cows say moo'));
$image = image(array('src' => 'pig.jpeg'));

遗憾的是，该方法要求您修改函数，因此我不喜欢它。另一个选项是使用this wrapper class，它允许您以下列方式之一使用命名参数：

$obj->method(array('key' => 'value', 'key2' => 'value2'));
$obj->method(':key = value', ':key2 = value2');

Answer 3

不，但你可以传入一个关联数组来处理这个问题：

f(array('C'=>3, 'A'=>1, 'B'=>1));

然后通过以下方式访问它：

function f($obj)
{
   $c = $obj['C'];
}

Answer 4

另一种可能对某些人有用的方法是，将单个参数作为带有“关键字”的字符串传递，例如...

    function foo($prms=""){
        isNAKED = (stripos(strtoupper($prms),"NAKED") !== false);
        showDETAILS = preg_match(...AS.NECESSARY...0)
        If (showDETAILS[0]){
           do what you do
        }
    }

然后，您的参数可以按任何顺序排列，可以一起丢失，并且字母大小写无关紧要。您可以预先决定如何对传递的值进行编码：DETAILS = 6或DETAILS（6）或其他任何方法。

因此，foo（“ NAKED DETAILS（6）”）将起作用，或者foo（“ DETAILS（6）NAKED”）将起作用。也可以使它与类似这样的东西一起工作...

foo（“ C = 3，A = 1，B = 1”）;

或-foo（“ C = $ C，A = 1，B = $ SOMETHINGELSEALLTOGETHERDIFFERENT”）;

它确实需要代码来解析出值

我发现在传递（并检测到）关键字（例如上面的“ NAKED”）时，这种方法最有效

Answer 5

从 php@8 开始，php will suppport named arguments。

这将允许以不同的顺序传递参数，只要您在调用时提供它们的名称即可。

例如这可能看起来像：

class SomeDto
{
    public function __construct(
        public int $foo = 'foo',
        public string $bar = 'bar',
        public string $baz = 'baz',
    ) {}
}

$example = new SomeDto($bar = 'fnord!');
// will result in an object { foo: 'foo', bar: 'fnord!', baz: 'baz'}

Answer 6

不，不使用standrad php语法。

当然总有一些技巧，比如你自己定义这个功能，你可以做点什么

F(array('C'=>3, 'A'=>1, 'B'=>1));

但是为此你必须重写原始函数，这样它就会接受一个数组作为参数，而不是只接受参数本身。

Answer 7

不，你不能。我为许多参数是可选的函数做了一些事情，或者我不想让顺序无关紧要的是使用单个数组参数。

function myfunc( $options ) {
     $one = $options['one'];
     $two = $options['two'];
     // etc.
}

Answer 8

取自here ......

如果您更喜欢对函数使用命名参数（因此您不必担心变量参数列表的顺序），您可以使用匿名数组执行PERL样式：

<?php
function foo($args)
{
    print "named_arg1 : " . $args["named_arg1"] . "\n";
    print "named_arg2 : " . $args["named_arg2"] . "\n";
}

foo(array("named_arg1" => "arg1_value", "named_arg2" => "arg2_value"));
?>

将输出：

named_arg1 : arg1_value
named_arg2 : arg2_value

Answer 9

来自php site：

在PHP 5.6和更高版本中，参数列表可能包含...令牌，以表示该函数接受可变数量的参数。参数将作为数组传递给给定变量；例如：

<?php
function sum(...$numbers) {
    $acc = 0;
    foreach ($numbers as $n) {
        $acc += $n;
    }
    return $acc;
}

echo sum(1, 2, 3, 4);
?>

与instanceof（如下）中的 is_subclass_of 或 here 一起进行后处理：

class Foo {

    public $foobar = 'Foo';

    public function test() {
        echo $this->foobar . "\n";
    }

}

class Bar extends Foo {

    public $foobar = 'Bar';

}

$a = new Foo();
$b = new Bar();

echo "use of test() method\n";
$a->test();
$b->test();

echo "instanceof Foo\n";
var_dump($a instanceof Foo); // TRUE
var_dump($b instanceof Foo); // TRUE

echo "instanceof Bar\n";
var_dump($a instanceof Bar); // FALSE
var_dump($b instanceof Bar); // TRUE

echo "subclass of Foo\n";
var_dump(is_subclass_of($a, 'Foo')); // FALSE
var_dump(is_subclass_of($b, 'Foo')); // TRUE

echo "subclass of Bar\n";
var_dump(is_subclass_of($a, 'Bar')); // FALSE
var_dump(is_subclass_of($b, 'Bar')); // FALSE

?>

Result (CLI, 5.4.4):

use of test() method
Foo
Bar
instanceof Foo
bool(true)
bool(true)
instanceof Bar
bool(false)
bool(true)
subclass of Foo
bool(false)
bool(true)
subclass of Bar
bool(false)
bool(false)

可以按照声明中定义的不同顺序传递php函数参数

9 个答案: