PHPKonf 2020 Online

Argumentos de funciones

Cualquier información puede ser pasada a las funciones mediante la lista de argumentos, la cual es una lista de expresiones delimitadas por comas. Los argumentos son evaluados de izquierda a derecha.

PHP admite el paso de argumentos por valor (lo predeterminado), el paso por referencia, y valores de argumentos predeterminados. Las Listas de argumentos de longitud variable también están soportadas.

Ejemplo #1 Pasar arrays a funciones

<?php
function tomar_array($entrada)
{
    echo 
"$entrada[0] + $entrada[1] = ".$entrada[0]+$entrada[1];
}
?>

Paso de argumentos por referencia

Por defecto, los argumentos de las funciones son pasados por valor (así, si el valor del argumento dentro de la función cambia, este no cambia fuera de la función). Para permitir a una función modificar sus argumentos, éstos deben pasarse por referencia.

Para hacer que un argumento a una función sea siempre pasado por referencia hay que anteponer al nombre del argumento el signo 'et' (&) en la definición de la función:

Ejemplo #2 Paso de parámetros de una función por referencia

<?php
function añadir_algo(&$cadena)
{
    
$cadena .= 'y algo más.';
}
$cad 'Esto es una cadena, ';
añadir_algo($cad);
echo 
$cad;    // imprime 'Esto es una cadena, y algo más.'
?>

Valores de argumentos predeterminados

Una función puede definir valores predeterminados al estilo de C++ para argumentos escalares como sigue:

Ejemplo #3 Uso de parámetros predeterminados en funciones

<?php
function hacer_café($tipo "capuchino")
{
    return 
"Hacer una taza de $tipo.\n";
}
echo 
hacer_café();
echo 
hacer_café(null);
echo 
hacer_café("espresso");
?>

El resultado del ejemplo sería:

Hacer una taza de capuchino.
Hacer una taza de .
Hacer una taza de espresso.

PHP también permite el uso de arrays y del tipo especial NULL como valores predeterminados, por ejemplo:

Ejemplo #4 Usar tipos no escalares como valores predeterminados

<?php
function hacer_café($tipos = array("capuchino"), $fabricanteCafé NULL)
{
    
$aparato is_null($fabricanteCafé) ? "las manos" $fabricanteCafé;
    return 
"Hacer una taza de ".join(", "$tipos)." con $aparato.\n";
}
echo 
hacer_café();
echo 
hacer_café(array("capuchino""lavazza"), "una tetera");
?>

El valor predeterminado debe ser una expresión constante, no (por ejemplo) una variable, un miembro de una clase o una llamada a una función.

Obsérvese que cuando se emplean argumentos predeterminados, cualquiera de ellos debería estar a la derecha de los argumentos no predeterminados; si no, las cosas no funcionarán como se esperaba. Considérese el siguiente trozo de código:

Ejemplo #5 Uso incorrecto de argumentos predeterminados en una función

<?php
function hacer_yogur($tipo "acidófilo"$sabor)
{
    return 
"Hacer un tazón de yogur $tipo de $sabor.\n";
}

echo 
hacer_yogur("frambuesa");   // no funcionará como se esperaba
?>

El resultado del ejemplo sería:

Warning: Missing argument 2 in call to hacer_yogur() in
/usr/local/etc/httpd/htdocs/phptest/functest.html on line 41
Hacer un tazón de yogur frambuesa de .

Ahora, compare el ejemplo de arriba con este:

Ejemplo #6 Uso correcto de argumentos predeterminados en una función

<?php
function hacer_yogur($sabor$tipo "acidófilo")
{
    return 
"Hacer un tazón de yogur $tipo de $sabor.\n";
}

echo 
hacer_yogur("frambuesa");   // funciona como se esperaba
?>

El resultado del ejemplo sería:

Hacer un tazón de yogur acidófilo de frambuensa.

Nota: A partir de PHP 5, los argumentos pasados por referencia pueden tener un valor predeterminado.

Declaraciones de tipo

Nota:

La declaración de tipos también se conoce como 'Determinación de tipos' en PHP 5.

Las declaraciones de tipo permiten a las funciones requerir que los parámetros sean de cierto tipo durante una llamada. Si el valor dado es de un tipo incorrecto, se generará un error: en PHP 5, este error es un error fatal recuperable, mientras que PHP 7 lanzará una excepción TypeError.

Para especificar una declaración de tipo, debe anteponerse el nombre del tipo al nombre del parámetro. Se puede hacer que una declaración acepte valores NULL si el valor predeterminado del parámetro se establece a NULL.

Tipos válidos

Tipo Descripción Versión de PHP mínima
nombre de clase/interfaz El parámetro debe ser una instanceof del nombre de la clase o interfaz dada. PHP 5.0.0
self El parámetro debe ser una instanceof de la misma clase donde está definido el método. Esto solamente se puede utilizar en clases y métodos de instancia. PHP 5.0.0
array El parámetro debe ser un array. PHP 5.1.0
callable El parámetro debe ser un callable válido. PHP 5.4.0
bool El parámetro debe ser un valor de tipo boolean. PHP 7.0.0
float El parámetro debe ser un número de tipo float. PHP 7.0.0
int El parámetro debe ser un valor de tipo integer. PHP 7.0.0
string El parámetro debe ser un string. PHP 7.0.0
iterable El parámetro debe ser un array o una instanceof Traversable. PHP 7.1.0
object El parámetro debe ser un object. PHP 7.2.0
Advertencia

Los alias de los tipos escalares anteriores no están admitidos. En su lugar, son tratados como nombres de clases o de interfaces. Por ejemplo, el empleo de boolean como parámetro o como tipo devuelto requerirá un argumento o un valor devuelto que sea unaan instanceof de la clase o interfaz boolean, más que el tipo bool:

<?php
 
function prueba(boolean $param) {}
 
prueba(true);
 
?>

El resultado del ejemplo sería:

 Fatal error: Uncaught TypeError: Argument 1 passed to test() must be an instance of boolean, boolean given, called in - on line 1 and defined in -:1
 

Ejemplos

Ejemplo #7 Declaración básica de tipo clase

<?php
class {}
class 
extends {}

// Esta no extiende a C.
class {}

function 
f(C $c) {
    echo 
get_class($c)."\n";
}

f(new C);
f(new D);
f(new E);
?>

El resultado del ejemplo sería:

C
D

Fatal error: Uncaught TypeError: Argument 1 passed to f() must be an instance of C, instance of E given, called in - on line 14 and defined in -:8
Stack trace:
#0 -(14): f(Object(E))
#1 {main}
  thrown in - on line 8

Ejemplo #8 Declaración básica de tipo interfaz

<?php
interface { public function f(); }
class 
implements { public function f() {} }

// Esta no implementa I.
class {}

function 
f(I $i) {
    echo 
get_class($i)."\n";
}

f(new C);
f(new E);
?>

El resultado del ejemplo sería:

C

Fatal error: Uncaught TypeError: Argument 1 passed to f() must implement interface I, instance of E given, called in - on line 13 and defined in -:8
Stack trace:
#0 -(13): f(Object(E))
#1 {main}
  thrown in - on line 8

Ejemplo #9 Tipos de parámetros pasados por referencia

Los tipos declarados de parámetros de referencia se comprueban en la entrada de la función, pero no cuando la función vuelve, así que después de que la función haya vuelto, el el tipo de argumento puede haber cambiado.

<?php
function array_baz(array &$param)
{
    
$param 1;
}
$var = [];
array_baz($var);
var_dump($var);
array_baz($var);
?>

El resultado del ejemplo sería algo similar a:

int(1)

Fatal error: Uncaught TypeError: Argument 1 passed to array_baz() must be of the type array, int given, called in %s on line %d

Ejemplo #10 Declaración de tipo nulo

<?php
class {}

function 
f(C $c null) {
    
var_dump($c);
}

f(new C);
f(null);
?>

El resultado del ejemplo sería:

object(C)#1 (0) {
}
NULL

Tipificación estricta

Por defecto, PHP fuerza a los valores de un tipo erróneo a ser del tipo escalar esperado si es posible. Por ejemplo, una función a la que se le pasa un integer para un parámetro que se prevé sea un string obtendrá una variable de tipo string.

Es posible habilitar el modo estricto en función de cada fichero. El el modo estricto solamente será aceptada una variable del tipo exacto de la declaración de tipo, o será lanzada una TypeError. La única excepción a esta regla es que se podría proporcionar un integer a una función que espere un float. Las llamadas a funciones desde dentro de funciones internas no se verán afectadas por la declaración strict_types.

Para habilitar el modo escricto se emplea la sentencia declare con la declaración strict_types:

Precaución

Habilitar el modo esctricto también afectará a las declaraciones de tipo de devolución.

Nota:

La tipificación estricta se aplica a las llamadas a funciones hechas desde dentro del fichero con la tipificación estricta habilitada, no a las funciones declaradas dentro del fichero. Si un fichero sin la tipificación estricta habilitada realiza una llamada a una función definida en un fichero con tipificación estricta, será respetada la preferencia del llamador (tipificación débil), y se forzará el valor.

Nota:

La tipificación estricta solamente se define para declaraciones de tipos escalares, y como tal, requiere PHP 7.0.0 o posterior, ya que las declaraciones de tipo escalar fueron añadidas en esta versión.

Ejemplo #11 Tipificación estricta

<?php
declare(strict_types=1);

function 
sum(int $aint $b) {
    return 
$a $b;
}

var_dump(sum(12));
var_dump(sum(1.52.5));
?>

El resultado del ejemplo sería:

int(3)

Fatal error: Uncaught TypeError: Argument 1 passed to sum() must be of the type integer, float given, called in - on line 9 and defined in -:4
Stack trace:
#0 -(9): sum(1.5, 2.5)
#1 {main}
  thrown in - on line 4

Ejemplo #12 Tipificación débil

<?php
function sum(int $aint $b) {
    return 
$a $b;
}

var_dump(sum(12));

// Estos números serán forzados a ser enteros: ¡observe la salida de abajo!
var_dump(sum(1.52.5));
?>

El resultado del ejemplo sería:

int(3)
int(3)

Ejemplo #13 Capturar la excepción TypeError

<?php
declare(strict_types=1);

function 
sum(int $aint $b) {
    return 
$a $b;
}

try {
    
var_dump(sum(12));
    
var_dump(sum(1.52.5));
} catch (
TypeError $e) {
    echo 
'Error: '.$e->getMessage();
}
?>

El resultado del ejemplo sería:

int(3)
Error: Argument 1 passed to sum() must be of the type integer, float given, called in - on line 10

Listas de argumentos de longitud variable

PHP tiene soporte para listas de argumentos de longitud variable en funciones definidas por el usuario. Esto se implementa utilizando el token ... en PHP 5.6 y posteriores, y utilizando las funciones func_num_args(), func_get_arg(), y func_get_args() en PHP 5.5 y anteriores.

... en PHP 5.6+

En PHP 5.6 y posteriores, las listas de argumentos pueden incluir el token ... para denotar que la función acepta un número variable de argumentos. Los argumentos serán pasados a la variable dada como un aryay, por ejemplo:

Ejemplo #14 Usando ... para acceder a argumentos variables

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

echo 
sum(1234);
?>

El resultado del ejemplo sería:

10

También se puede emplear ... al llamar a funciones para convertir un array o variable Traversable o literal en una lista de argumentos:

Ejemplo #15 Usar ... para proporcionar argumentos

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

echo 
add(...[12])."\n";

$a = [12];
echo 
add(...$a);
?>

El resultado del ejemplo sería:

3
3

Se puede especifcar argumentos posicionales normales antes del token .... En este caso, solamente los argumentos al final que no coincidan con un argumento posicional serán añadidos al array generado por ....

También es posible añadir una declraración de tipo antes del símbolo .... Si está presente, todos los argumentos capturados por ... deben ser objetos de la clase implicada.

Ejemplo #16 Argumentos variables de declaración de tipo

<?php
function total_intervals($unitDateInterval ...$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';

// Esto fallará, debido a que  null no es un objeto de DateInterval.
echo total_intervals('d'null);
?>

El resultado del ejemplo sería:

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

Por último, también es pueden pasar argumentos variables por referencia prefijando ... con el signo (&).

Versiones antiguas de PHP

No se requiere una sintaxis especial para señalar que una función es varíadica; sin embargo, para acceder a los argumentos de la función se debe usar func_num_args(), func_get_arg() y func_get_args().

El primer ejemplo de antes se implementaría en PHP 5.5 y anteriores como sigue:

Ejemplo #17 Acceder a argumentos variables en PHP 5.5 y anteriores

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

echo 
sum(1234);
?>

El resultado del ejemplo sería:

10

add a note add a note

User Contributed Notes 14 notes

up
96
php at richardneill dot org
5 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".
*/
?>
up
32
gabriel at figdice dot org
4 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
?>
up
16
jcaplan at bogus dot amazon dot com
14 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

?>
up
7
info at keraweb dot nl
3 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"
up
16
Sergio Santana: ssantana at tlaloc dot imta dot mx
15 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.
up
7
boan dot web at outlook dot com
2 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
?>
up
6
Hayley Watson
3 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.
up
8
Horst Schirmeier
6 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; }).
up
4
catman at esteticas dot se
4 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
up
2
dmitry dot balabka at gmail dot com
2 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
up
4
Hayley Watson
3 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.
up
3
igorsantos07 at gmail dot com
2 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
?>
up
5
John
14 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)
up
2
shaman_master at list dot ru
1 year 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);
    }
}
?>
To Top