PHP: 函数的参数 - PHP中文网

函数的参数

通过参数列表可以传递信息到函数，即以逗号作为分隔符的表达式列表。函数在实际调用之前，值参数是从左向右求值的（及早求值）。

PHP 支持按值传递参数（默认），通过引用传递参数以及默认参数。也支持可变长度参数列表和命名参数。

示例 #1 向函数传递数组

<?php
function takes_array($input)
{
    echo "$input[0] + $input[1] = ", $input[0]+$input[1];
}
?>

从 PHP 8.0.0 开始，函数参数列表可以包含一个尾部的逗号，这个逗号将被忽略。这在参数列表较长或包含较长的变量名的情况下特别有用，这样可以方便地垂直列出参数。

示例 #2 函数参数使用尾部逗号

<?php
function takes_many_args(
    $first_arg,
    $second_arg,
    $a_very_long_argument_name,
    $arg_with_default = 5,
    $again = 'a default string', // 在 8.0.0 之前，这个尾部的逗号是不允许的。
)
{
    // ...
}
?>

通过引用传递参数

默认情况下，函数参数通过值传递（因而即使在函数内部改变参数的值，它并不会改变函数外部的值）。如果希望允许函数修改它的参数值，必须通过引用传递参数。

如果想要函数的一个参数总是通过引用传递，可以在函数定义中该参数的前面加上符号 &：

示例 #3 用引用传递函数参数

<?php
function add_some_extra(&$string)
{
    $string .= 'and something extra.';
}
$str = 'This is a string, ';
add_some_extra($str);
echo $str;    // 输出 'This is a string, and something extra.'
?>

默认参数的值

函数可以使用类似分配变量的语法定义参数的默认值。仅当参数未指定时才使用默认值；需要注意的是传递 null 不会分配默认值。

示例 #4 在函数中使用默认参数

<?php
function makecoffee($type = "cappuccino")
{
    return "Making a cup of $type.\n";
}
echo makecoffee();
echo makecoffee(null);
echo makecoffee("espresso");
?>

以上示例会输出：

 
Making a cup of cappuccino.
Making a cup of .
Making a cup of espresso.

默认参数值可以是标量值、array、特殊类型 null，以及从 PHP 8.1.0 开始，使用 new ClassName() 语法的对象。

示例 #5 使用非标量类型作为默认参数

<?php
function makecoffee($types = array("cappuccino"), $coffeeMaker = NULL)
{
    $device = is_null($coffeeMaker) ? "hands" : $coffeeMaker;
    return "Making a cup of ".join(", ", $types)." with $device.\n";
}
echo makecoffee();
echo makecoffee(array("cappuccino", "lavazza"), "teapot");?>

示例 #6 使用对象作为默认值（自 PHP 8.1.0 起）

<?php
class DefaultCoffeeMaker {
    public function brew() {
        return 'Making coffee.';
    }
}
class FancyCoffeeMaker {
    public function brew() {
        return 'Crafting a beautiful coffee just for you.';
    }
}
function makecoffee($coffeeMaker = new DefaultCoffeeMaker)
{
    return $coffeeMaker->brew();
}
echo makecoffee();
echo makecoffee(new FancyCoffeeMaker);
?>

默认值必须是常量表达式，不能是诸如变量，类成员，或者函数调用等。

注意任何可选参数都应在强制参数之后指定，否则可选参数不能在调用时省略。考虑以下示例：

示例 #7 函数默认参数的不正确用法

<?php
function makeyogurt($container = "bowl", $flavour)
{
    return "Making a $container of $flavour yogurt.\n";
}
 
echo makeyogurt("raspberry"); // "raspberry" 是 $container, 不是 $flavour
?>

以上示例会输出：

 
Fatal error: Uncaught ArgumentCountError: Too few arguments
 to function makeyogurt(), 1 passed in example.php on line 42

现在，比较上面的例子和这个例子：

示例 #8 函数默认参数正确的用法

<?php
function makeyogurt($flavour, $container = "bowl")
{
    return "Making a $container of $flavour yogurt.\n";
}
 
echo makeyogurt("raspberry"); // "raspberry" 是 $flavour
?>

以上示例会输出：

 
Making a bowl of raspberry yogurt.

自 PHP 8.0.0 起，命名参数可用于跳过多个可选参数。

示例 #9 函数默认参数正确的用法

<?php
function makeyogurt($container = "bowl", $flavour = "raspberry", $style = "Greek")
{
    return "Making a $container of $flavour $style yogurt.\n";
}

echo makeyogurt(style: "natural");
?>

以上示例会输出：

 
Making a bowl of raspberry natural yogurt.

自 PHP 8.0.0 起，弃用在可选参数之后声明强制参数。这通常可以通过删除默认值来解决，因为它永远不会被使用。唯一的例外是 Type $param = null 类型的参数，其中默认 null 使得该类型可以隐式为 null。这种做法依然允许，但是推荐使用显式可为 null 类型代替。

示例 #10 强制参数后声明可选参数

<?php
 function foo($a = [], $b) {} // 默认不使用；自 PHP 8.0.0 起弃用
 function foo($a, $b) {}      // 功能相同，无弃用通知

 function bar(A $a = null, $b) {} // 仍然允许；但 $a 强制但可以为 null
 function bar(?A $a, $b) {}       // 推荐
 ?>

注意: 自 PHP 7.1.0 起，省略未指定默认值的参数会原因引发 ArgumentCountError；在此之前的版本会引发警告。

注意: 传引用的参数也可以有默认值。

可变数量的参数列表

PHP 在用户自定义函数中支持可变数量的参数列表。由 ... 语法实现。

包含 ... 的参数，会转换为指定参数变量的一个 array：

示例 #11 使用 ... 来访问变量参数

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

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

以上示例会输出：

也可以使用 ... 语法来传递 array 或 Traversable 做为参数到函数中：

示例 #12 使用 ... 来传递参数

<?php
function add($a, $b) {
    return $a + $b;
}

echo add(...[1, 2])."\n";

$a = [1, 2];
echo add(...$a);
?>

以上示例会输出：

3
3

你可以在 ... 前指定正常的位置参数。在这种情况下，只有不符合位置参数的尾部参数才会被添加到 ... 生成的数组中。

你也可以在 ... 标记前添加一个类型声明。如果存在这种情况，那么 ... 捕获的所有参数都必须匹配参数类型。

示例 #13 输入提示的变量参数

<?php
function total_intervals($unit, DateInterval ...$intervals) {
    $time = 0;
    foreach ($intervals as $interval) {
        $time += $interval->$unit;
    }
    return $time;
}

$a = new DateInterval('P1D');
$b = new DateInterval('P2D');
echo total_intervals('d', $a, $b).' days';

// 这将会失败，因为 null 不是 DateInterval 对象。
echo total_intervals('d', null);
?>

以上示例会输出：

 
3 days
Catchable fatal error: Argument 2 passed to total_intervals() must be an instance of DateInterval, null given, called in - on line 14 and defined in - on line 2

最后，你还可以给参数传递引用变量，通过在 ... 前加上一个 (&) 符号来实现。

命名参数

PHP 8.0.0 开始引入了命名参数作为现有位置参数的扩展。命名参数允许根据参数名而不是参数位置向函数传参。这使得参数的含义自成体系，参数与顺序无关，并允许任意跳过默认值。

命名参数通过在参数名前加上冒号来传递。允许使用保留关键字作为参数名。参数名必须是一个标识符，不允许动态指定。

示例 #14 命名参数的语法

<?php
myFunction(paramName: $value);
array_foobar(array: $value);

// 不支持。
function_name($variableStoringParamName: $value);
?>

示例 #15 通过位置传参与命名参数的对比

<?php
// 使用顺序传递参数：
array_fill(0, 100, 50);

// 使用命名参数：
array_fill(start_index: 0, count: 100, value: 50);
?>

指定参数的传递顺序并不重要。

示例 #16 参数顺序不同的示例（同上例）

<?php
array_fill(value: 50, count: 100, start_index: 0);
?>

命名参数也可以与位置参数相结合使用。此种情况下，命名参数必须在位置参数之后。也可以只指定一个函数的部分可选参数，而不考虑它们的顺序。

示例 #17 命名参数与位置参数结合使用

<?php
htmlspecialchars($string, double_encode: false);
// 等价于
htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, 'UTF-8', false);
?>

传递多个相同参数将会导致 Error 异常。

示例 #18 传递多个相同参数将会导致抛出 Error

<?php
function foo($param) { ... }

foo(param: 1, param: 2);
// 错误：命名参数 $param 覆盖了之前的参数
foo(1, param: 2);
// 错误：命名参数 $param 覆盖了之前的参数
?>

自 PHP 8.1.0 起，可以在解包参数后面使用命名参数。命名参数不能覆盖已解包的参数。

示例 #19 解包后使用命名参数

<?php
function foo($a, $b, $c = 3, $d = 4) {
  return $a + $b + $c + $d;
}

var_dump(foo(...[1, 2], d: 40)); // 46
var_dump(foo(...['b' => 2, 'a' => 1], d: 40)); // 46

var_dump(foo(...[1, 2], b: 20)); // Fatal error。命名参数 $b 覆盖之前的参数
?>

＋add a note

User Contributed Notes 21 notes

down

114

php at richardneill dot org ¶

8 years ago

To experiment on performance of pass-by-reference and pass-by-value, I used this  script. Conclusions are below. 

#!/usr/bin/php
<?php
function sum($array,$max){   //For Reference, use:  "&$array"
    $sum=0;
    for ($i=0; $i<2; $i++){
        #$array[$i]++;        //Uncomment this line to modify the array within the function.
        $sum += $array[$i];  
    }
    return ($sum);
}

$max = 1E7                  //10 M data points.
$data = range(0,$max,1);

$start = microtime(true);
for ($x = 0 ; $x < 100; $x++){
    $sum = sum($data, $max);
}
$end =  microtime(true);
echo "Time: ".($end - $start)." s\n";

/* Run times:
#    PASS BY    MODIFIED?   Time
-    -------    ---------   ----
1    value      no          56 us
2    reference  no          58 us

3    valuue     yes         129 s
4    reference  yes         66 us

Conclusions:

1. PHP is already smart about zero-copy / copy-on-write. A function call does NOT copy the data unless it needs to; the data is
   only copied on write. That's why  #1 and #2 take similar times, whereas #3 takes 2 million times longer than #4.
   [You never need to use &$array to ask the compiler to do a zero-copy optimisation; it can work that out for itself.]

2. You do use &$array  to tell the compiler "it is OK for the function to over-write my argument in place, I don't need the original
   any more." This can make a huge difference to performance when we have large amounts of memory to copy.
   (This is the only way it is done in C, arrays are always passed as pointers)

3. The other use of & is as a way to specify where data should be *returned*. (e.g. as used by exec() ).
   (This is a C-like way of passing pointers for outputs, whereas PHP functions normally return complex types, or multiple answers
   in an array)

4. It's  unhelpful that only the function definition has &. The caller should have it, at least as syntactic sugar. Otherwise
   it leads to unreadable code: because the person reading the function call doesn't expect it to pass by reference. At the moment,
   it's necessary to write a by-reference function call with a comment, thus:
    $sum = sum($data,$max);  //warning, $data passed by reference, and may be modified.

5. Sometimes, pass by reference could be at the choice of the caller, NOT the function definitition. PHP doesn't allow it, but it
   would be meaningful for the caller to decide to pass data in as a reference. i.e. "I'm done with the variable, it's OK to stomp
   on it in memory".
*/
?>

down

LilyWhite ¶

2 years ago

It is worth noting that you can use functions as function arguments

<?php
function run($op, $a, $b) {
  return $op($a, $b);
}

$add = function($a, $b) {
  return $a + $b;
};

$mul = function($a, $b) {
  return $a * $b;
};

echo run($add, 1, 2), "\n";
echo run($mul, 1, 2);
?>

Output:
3
2

down

gabriel at figdice dot org ¶

7 years ago

A function's argument that is an object, will have its properties modified by the function although you don't need to pass it by reference.

<?php
$x = new stdClass();
$x->prop = 1;

function f ( $o ) // Notice the absence of &
{
  $o->prop ++;
}

f($x);

echo $x->prop; // shows: 2
?>

This is different for arrays:

<?php
$y = [ 'prop' => 1 ];

function g( $a )
{
  $a['prop'] ++;
  echo $a['prop'];  // shows: 2
}

g($y);

echo $y['prop'];  // shows: 1
?>

down

Hayley Watson ¶

6 years ago

There are fewer restrictions on using ... to supply multiple arguments to a function call than there are on using it to declare a variadic parameter in the function declaration. In particular, it can be used more than once to unpack arguments, provided that all such uses come after any positional arguments.

<?php

$array1 = [[1],[2],[3]];
$array2 = [4];
$array3 = [[5],[6],[7]];

$result = array_merge(...$array1); // Legal, of course: $result == [1,2,3];
$result = array_merge($array2, ...$array1); // $result == [4,1,2,3]
$result = array_merge(...$array1, $array2); // Fatal error: Cannot use positional argument after argument unpacking.
$result = array_merge(...$array1, ...$array3); // Legal! $result == [1,2,3,5,6,7]
?>

The Right Thing for the error case above would be for $result==[1,2,3,4], but this isn't yet (v7.1.8) supported.

down

Luna ¶

10 months ago

When using named arguments and adding default values only to some of the arguments, the arguments with default values must be specified at the end or otherwise PHP throws an error:

<?php

function test1($a, $c, $b = 2)
{
    return $a + $b + $c;
}

function test2($a, $b = 2, $c)
{
    return $a + $b + $c;
}

echo test1(a: 1, c: 3)."\n"; // Works
echo test2(a: 1, c: 3)."\n"; // ArgumentCountError: Argument #2 ($b) not passed

?>

I assume that this happens because internally PHP rewrites the calls to something like test1(1, 3) and test2(1, , 3). The first call is valid, but the second obviously isn't.

down

boan dot web at outlook dot com ¶

5 years ago

Quote:

"The declaration can be made to accept NULL values if the default value of the parameter is set to NULL."

But you can do this (PHP 7.1+):

<?php
function foo(?string $bar) {
    //...
}

foo(); // Fatal error
foo(null); // Okay
foo('Hello world'); // Okay
?>

down

jcaplan at bogus dot amazon dot com ¶

17 years ago

In function calls, PHP clearly distinguishes between missing arguments and present but empty arguments.  Thus:

<?php
function f( $x = 4 ) { echo $x . "\\n"; }
f(); // prints 4
f( null ); // prints blank line
f( $y ); // $y undefined, prints blank line
?>

The utility of the optional argument feature is thus somewhat diminished.  Suppose you want to call the function f many times from function g, allowing the caller of g to specify if f should be called with a specific value or with its default value:

<?php
function f( $x = 4 ) {echo $x . "\\n"; }

// option 1: cut and paste the default value from f's interface into g's
function g( $x = 4 ) { f( $x ); f( $x ); }

// option 2: branch based on input to g
function g( $x = null ) { if ( !isset( $x ) ) { f(); f() } else { f( $x ); f( $x ); } }
?>

Both options suck.

The best approach, it seems to me, is to always use a sentinel like null as the default value of an optional argument.  This way, callers like g and g's clients have many options, and furthermore, callers always know how to omit arguments so they can omit one in the middle of the parameter list.

<?php
function f( $x = null ) { if ( !isset( $x ) ) $x = 4; echo $x . "\\n"; }

function g( $x = null ) { f( $x ); f( $x ); }

f(); // prints 4
f( null ); // prints 4
f( $y ); // $y undefined, prints 4
g(); // prints 4 twice
g( null ); // prints 4 twice
g( 5 ); // prints 5 twice

?>

down

Sergio Santana: ssantana at tlaloc dot imta dot mx ¶

18 years ago

PASSING A "VARIABLE-LENGTH ARGUMENT LIST OF REFERENCES" TO A FUNCTION
As of PHP 5, Call-time pass-by-reference has been deprecated, this represents no problem in most cases, since instead of calling a function like this:
   myfunction($arg1, &$arg2, &$arg3);

you can call it
   myfunction($arg1, $arg2, $arg3);

provided you have defined your function as 
   function myfuncion($a1, &$a2, &$a3) { // so &$a2 and &$a3 are 
                                                             // declared to be refs.
    ... <function-code>
   }

However, what happens if you wanted to pass an undefined number of references, i.e., something like:
   myfunction(&$arg1, &$arg2, ..., &$arg-n);?
This doesn't work in PHP 5 anymore.

In the following code I tried to amend this by using the 
array() language-construct as the actual argument in the 
call to the function.

<?php

  function aa ($A) {
    // This function increments each 
    // "pseudo-argument" by 2s
    foreach ($A as &$x) { 
      $x += 2;
    }
  }
 
  $x = 1; $y = 2; $z = 3;
  
  aa(array(&$x, &$y, &$z));
  echo "--$x--$y--$z--\n";
  // This will output:
  // --3--4--5--
?>

I hope this is useful.

Sergio.

down

catman at esteticas dot se ¶

7 years ago

I wondered if variable length argument lists and references works together, and what the syntax might be. It is not mentioned explicitly yet in the php manual as far as I can find. But other sources mention the following syntax "&...$variable" that works in php  5.6.16. 

<?php
function foo(&...$args)
{
    $i = 0;
    foreach ($args as &$arg) {
        $arg = ++$i;
    }
}
foo($a, $b, $c);
echo 'a = ', $a, ', b = ', $b, ', c = ', $c;
?>
Gives
a = 1, b = 2, c = 3

down

Hayley Watson ¶

6 years ago

If you use ... in a function's parameter list, you can use it only once for obvious reasons. Less obvious is that it has to be on the LAST parameter; as the manual puts it: "You may specify normal positional arguments BEFORE the ... token. (emphasis mine).

<?php
function variadic($first, ...$most, $last)
{/*etc.*/}

variadic(1, 2, 3, 4, 5);
?>
results in a fatal error, even though it looks like the Thing To Do™ would be to set $first to 1, $most to [2, 3, 4], and $last to 5.

down

info at keraweb dot nl ¶

6 years ago

You can use a class constant as a default parameter.

<?php

class A {
    const FOO = 'default';
    function bar( $val = self::FOO ) {
        echo $val;
    }
}

$a = new A();
$a->bar(); // Will echo "default"

down

Simmo at 9000 dot 000 ¶

1 year ago

For anyone just getting started with php or searching, for an understanding, on what this page describes as a "... token" in Variable-length arguments:
/manual/en/functions.arguments.php#functions.variable-arg-list
<?php

  func($a, ...$b) 

?>
The 3 dots, or elipsis, or "...", or dot dot dot is sometimes called the "spread operator" in other languages.

As this is only used in function arguments, it is probably not technically an true operator in PHP.  (As of 8.1 at least?).

(With having an difficult to search for name like "... token", I hope this note helps someone).

down

tianyiw at vip dot qq dot com ¶

1 year ago

<?php
/**
 * Create an array using Named Parameters.
 *
 * @param mixed ...$values
 * @return array
 */
function arr(mixed ...$values): array
{
    return $values;
}

$arr = arr(
    name: 'php',
    mobile: 123456,
);

var_dump($arr);
// array(2) {
//   ["name"]=>
//   string(3) "php"
//   ["mobile"]=>
//   int(123456)
// }

down

TwystO ¶

1 year ago

As stated in the documentation, the ... token can be used to pass an array of parameters to a function.

But it also works for class constructors as you can see below :

<?php

class Courtesy {
    public string $firstname;
    public string $lastname;
    
    public function __construct($firstname, $lastname) {
        $this->firstname = $firstname;
        $this->lastname = $lastname;
    }
    
    public function hello() {
        return 'Hello ' . $this->firstname . ' ' . $this->lastname . '!';
    }
}

$params = [ 'John', 'Doe' ];

$courtesy = new Courtesy(...$params);

echo $courtesy->hello();

?>

down

Horst Schirmeier ¶

9 years ago

Editor's note: what is expected here by the parser is a non-evaluated expression. An operand and two constants requires evaluation, which is not done by the parser. However, this feature is included as of PHP 5.6.0. See this page for more information: http://php.net/migration56.new-features#migration56.new-features.const-scalar-exprs

--------



"The default value must be a constant expression" is misleading (or even wrong).  PHP 5.4.4 fails to parse this function definition:



function htmlspecialchars_latin1($s, $flags = ENT_COMPAT | ENT_HTML401) {}



This yields a " PHP Parse error:  syntax error, unexpected '|', expecting ')' " although ENT_COMPAT|ENT_HTML401 is certainly what a compiler-affine person would call a "constant expression".



The obvious workaround is to use a single special value ($flags = NULL) as the default, and to set it to the desired value in the function's body (if ($flags === NULL) { $flags = ENT_COMPAT | ENT_HTML401; }).

down

dmitry dot balabka at gmail dot com ¶

4 years ago

There is a possibility to use parent keyword as type hint which is not mentioned in the documentation.

Following code snippet will be executed w/o errors on PHP version 7. In this example, parent keyword is referencing on ParentClass instead of ClassTrait.
<?php
namespace TestTypeHints;

class ParentClass
{
    public function someMethod()
    {
        echo 'Some method called' . \PHP_EOL;
    }
}

trait ClassTrait
{
    private $original;

    public function __construct(parent $original)
    {
        $this->original = $original;
    }

    protected function getOriginal(): parent
    {
        return $this->original;
    }
}

class Implementation extends ParentClass
{
    use ClassTrait;

    public function callSomeMethod()
    {
        $this->getOriginal()->someMethod();
    }
}

$obj = new Implementation(new ParentClass());
$obj->callSomeMethod();
?>

Outputs:
Some method called

down

John ¶

16 years ago

This might be documented somewhere OR obvious to most, but when passing an argument by reference (as of PHP 5.04) you can assign a value to an argument variable in the function call. For example:

function my_function($arg1, &$arg2) {
  if ($arg1 == true) {
    $arg2 = true;
  }
}
my_function(true, $arg2 = false);
echo $arg2;

outputs 1 (true)

my_function(false, $arg2 = false);
echo $arg2;

outputs 0 (false)

down

-1

igorsantos07 at gmail dot com ¶

5 years ago

PHP 7+ does type coercion if strict typing is not enabled, but there's a small gotcha: it won't convert null values into anything.

You must explicitly set your default argument value to be null (as explained in this page) so your function can also receive nulls.

For instance, if you type an argument as "string", but pass a null variable into it, you might expect to receive an empty string, but actually, PHP will yell at you a TypeError.

<?php
function null_string_wrong(string $str) {
  var_dump($str);
}
function null_string_correct(string $str = null) {
  var_dump($str);
}
$null = null;
null_string_wrong('a');     //string(1) "a"
null_string_correct('a');   //string(1) "a"
null_string_correct();      //NULL
null_string_correct($null); //NULL
null_string_wrong($null);   //TypeError thrown
?>

down

-3

rsperduta at gmail dot com ¶

2 years ago

About example #2: That little comma down at the end and often obscured by a line comment is easily over looked. I think it's worth considering putting it at the head of the next line to make clear what it's relationship is to the surrounding lines. Consider how much clearer it's continuation as a list of parameters:

<?php
function takes_many_args(
    $first_arg // some description
    , $second_arg // another comment
    , $a_very_long_argument_name = something($complicated) // IDK
    , $arg_with_default = 5
    , $again = 'a default string', // IMHO this trailing comma encourages illegible code and not being permitted seemed  a good idea lost with 8.0.0.
) {
    // ...
}
?>

 This principle can be applied equally to complicated boolean expressions of an "if" statement (or the parts of a for statement).

down

-2

tesdy14 at gmail dot com ¶

2 years ago

function my_fonction(string $value) {
    echo $value . PHP_EOL;
}

my_fonction(['foo' => 'ko', 'bar' => 'not', 'goodValue' => 'Oh Yeah']['goodValue']);

// return 'Oh Yeah'

// This may sound strange, anyway it's very useful in a foreach (or other conditional structure).

$expectedStatusCodes = [404, 403];

function getValueFromArray(string $value): string
{
    return $value . PHP_EOL;
}

foreach ($expectedStatusCodes as $code) {
    echo $currentUserReference = getValueFromArray(
        [
            404 => "Doesn't exist",
            403 => 'Forbidden',
            200 => "you're welcome"
        ][$code]
    );
}

down

-8

shaman_master at list dot ru ¶

3 years ago

You can use the class/interface as a type even if the class/interface is not  defined yet or the class/interface implements current class/interface.
<?php
interface RouteInterface
{
    public function getGroup(): ?RouteGroupInterface;
}
interface RouteGroupInterface extends RouteInterface
{
    public function set(RouteInterface $item);
}
?>
'self' type - alias to current class/interface, it's not changed in implementations. This code looks right but throw error:
<?php
class Route
{
    protected $name;
     // method must return Route object
    public function setName(string $name): self
    {
         $this->name = $name;
         return $this;
    }
}
class RouteGroup extends Route
{
    // method STILL must return only Route object
    public function setName(string $name): self
    {
         $name .= ' group';
         return parent::setName($name);
    }
}
?>

＋add a note