PHP 8.0.6 Released!

Argumentos de funções

Informações podem ser passadas para funções através da lista de argumentos, que é uma lista de expressões delimitados por vírgulas. Os argumentos são avaliados da esquerda para a direita.

O PHP suporta a passagem de argumentos por valor (o padrão), passagem por referência, e valores padrões de argumentos. lista de argumentos de tamanho variável também são suportadas.

Exemplo #1 Passando arrays para funções

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

Fazendo argumentos serem passados por referência

Por padrão, argumentos de função são passados por valor (de forma que se você mudar o valor do parâmetro dentro da função, ele não é alterado fora da função). Para permitir que uma função modifique os seus argumentos, eles devem ser passados por referência.

Para ter um argumento para uma função sempre passado por referência, adicione antes dele um "e comercial" (&) ao nome do argumento na definição da função:

Exemplo #2 Passando parâmetros de função por referência

<?php
function add_some_extra(&$string)
{
    
$string .= ' e alguma coisa mais.';
}
$str 'Isto é uma string,';
add_some_extra($str);
echo 
$str;    // imprime 'Isto é uma string, e alguma coisa mais.'
?>

Valores padrão de argumentos

Uma função pode definir valores padrão no estilo C++ para argumentos escalares, como a seguir:

Exemplo #3 Utilizando parâmetros padrão em funções

<?php
function makecoffee($type "cappuccino")
{
    return 
"Fazendo uma xícara de café $type.\n";
}
echo 
makecoffee();
echo 
makecoffee(null);
echo 
makecoffee("espresso");
?>

O exemplo acima irá imprimir:

Fazendo uma xícara de café cappuccino.
Fazendo uma xícara de café .
Fazendo uma xícara de café espresso.

O PHP também permite o uso def arrays e do tipo especial null como valores padrões, por exemplo:

Exemplo #4 Usando tipos não escalares como valores padrões

<?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");
?>

O valor padrão precisa ser uma expressão constante, não (por exemplo) uma variável, um membro de classe ou uma chamada de função.

Note que usando argumentos padrão, qualquer padrão deve vir após os argumentos sem padrão: caso contrário, as coisas não funcionarão como esperado. Considere o seguinte trecho de código:

Exemplo #5 Uso incorreto de parâmetros padrão de função

<?php
function iogurtera ($tipo "azeda"$sabor)
{
    return 
"Fazendo uma taça de $sabor $tipo.\n";
}

echo 
iogurtera ("framboesa");   // não funciona como esperado
?>

O exemplo acima irá imprimir:

Warning: Missing argument 2 in call to makeyogurt() in
/usr/local/etc/httpd/htdocs/phptest/functest.html on line 41
Fazendo uma taça de framboesa.

Agora, compare o que está acima com este:

Exemplo #6 Uso correto de parâmetros padrão de função

<?php
function iogurtera ($sabor$tipo "azeda")
{
    return 
"Fazendo uma taça de $sabor $tipo.\n";
}

echo 
iogurtera ("framboesa");   // funciona
?>

O exemplo acima irá imprimir:

Fazendo uma taça de framboesa azeda.

Nota: A partir do PHP 5, os valores padrões são passados por referência.

Declarações de tipo

Nota:

Declaração de tipos também era conhecida como type hints no PHP 5.

Declarações de tipo permitem que funções requiram que parâmetros sejam de certos tipos ao chamá-los. Se o valor informado no parâmetro tiver um tipo incorreto então um erro é gerado: no PHP 5 será um erro fatal recuperável, enquanto que no PHP 7 irá lançar uma exceção TypeError

Para declarar o tipo o seu nome deve ser adicionado antes no nome do parâmetro. A declaração pode ser feita para aceitar null se o valor default do parâmetro for configurado também para null.

Tipos válidos

Tipo Descrição Versão PHP Mínima
Classe/interface O parâmetro precisa ser um instanceof da classe ou interface informada. PHP 5.0.0
self O parâmetro precisa ser um instanceof da mesma classe do método onde a função está definida. Somente pode ser utilizado em métodos de classe e instância. PHP 5.0.0
array O parâmetro precisa ser um array. PHP 5.1.0
callable O parâmetro precisa ser um callable válido. PHP 5.4.0
bool O parâmetro precisa ser um valor boolean. PHP 7.0.0
float O parâmetro precisa ser um número float. PHP 7.0.0
int O parâmetro precisa ser um número integer. PHP 7.0.0
string O parâmetro precisa ser uma string. PHP 7.0.0
iterable O parâmetro precisa ser um array ou um instanceof Traversable. PHP 7.1.0
object O parâmetro precisa ser um object. PHP 7.2.0
Aviso

Apelidos para os tipos escalares acima não são suportados. Apelidos serão tradados como nomes de classe ou interface. Por exemplo, utilizar boolean como parâmetro ou tipo de retorno irá requerer um argumento ou retorno que seja um instanceof de uma classe ou interface boolean, em vez do tipo bool:

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

O exemplo acima irá imprimir:

 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
 

Exemplos

Exemplo #7 Declaração de tipos em classes

<?php
class {}
class 
extends {}

// This doesn't extend C.
class {}

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

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

O exemplo acima irá imprimir:

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

Exemplo #8 Declaração de tipos em interfaces

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

// This doesn't implement I.
class {}

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

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

O exemplo acima irá imprimir:

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

Exemplo #9 Passando parâmetros tipados por referência

Os tipos declarados de parâmetros de referência são verificados na entrada da função, mas não no retorno função, assim, depois que a função tiver retornado, o tipo de argumento pode ter mudado.

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

O exemplo acima irá imprimir algo similar à:

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

Exemplo #10 Declaração de tipos nulificáveis

<?php
class {}

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

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

O exemplo acima irá imprimir:

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

Tipagem estrita

Por padrão, se possível, o PHP irá converter o tipo incorreto no tipo escalar esperado. Por exemplo, uma função que passa um parâmetro integer onde se espera uma string receberá o valor com o tipo string.

É possível habilitar o modo estrito arquivo a arquivo. No modo estrito somente uma variável do exato tipo especificado na declaração será aceito, ou uma exceção TypeError será lançada. A única exceção é o tipo integer que poderá ser entregue a uma função esperando um float. Chamadas a funções de dentro de funções internas não serão afetadas pelas declarações strict_types

Para habilitar o modo estrito, utilize a instrução declare com a definição strict_types:

Cuidado

Habilitar o modo estrito também afetará as declarações de tipo de retorno.

Nota:

A tipagem estrita se aplica a chamadas feitas a partir do arquivo em que a tipagem estrita foi habilitada, não necessariamente às funções declaradas com tipos. Se um arquivo sem tipagem estrita tentar fazer uma chamada a uma função com tipagem estrita, a preferência do chamador (tipagem fraca) será respeitada, e o valor será possivelmente convertido.

Nota:

A tipagem estrita somente ocorre para declarações de tipo escalar, e portanto requer PHP 7.0.0 ou posterior, dado que declarações escalares foram acrescentadas nessa versão.

Exemplo #11 Tipagem estrita

<?php
declare(strict_types=1);

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

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

O exemplo acima irá imprimir:

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

Exemplo #12 Tipagem fraca

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

var_dump(sum(12));

// These will be coerced to integers: note the output below!
var_dump(sum(1.52.5));
?>

O exemplo acima irá imprimir:

int(3)
int(3)

Exemplo #13 Catching 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();
}
?>

O exemplo acima irá imprimir:

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

Número variável de argumentos

O PHP tem suporte para um número variável de argumentos nas funções definidas pelo usuário. Isso é implementado usando o token ... a partir do PHP 5.6, e usando as funções func_num_args(), func_get_arg(), e func_get_args() a partir do PHP 5.5.

... no PHP 5.6+

A partir do PHP 5.6 é possível incluir o indicador de lista de argumentos ... para informar que a função aceita um número variável de argumentos. Os argumentos serão passados na forma de um array. Por exemplo.

Exemplo #14 Utilizando ... para acessar argumentos variáveis

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

echo 
sum(1234);
?>

O exemplo acima irá imprimir:

10

Você também pode utilizar ... quando chamando funções para transformar uma variável array, Traversable ou literal em uma lista de argumentos.

Exemplo #15 Utilizando ... para fornecer argumentos

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

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

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

O exemplo acima irá imprimir:

3
3

Você pode especificar argumentos posicionais antes do indicador. .... Nesse caso comente os argumentos finais, que não pareiem com um argumento posicional, serão adicionados ao array gerado por ....

É também possível adicionar um type hint antes do indicador .... Se presente então todos os argumentos capturados por ... deverão ser objetos da classe informada.

Exemplo #16 Argumentos variáveis com type hint

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

// This will fail, since null isn't a DateInterval object.
echo total_intervals('d'null);
?>

O exemplo acima irá imprimir:

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

Finalmente, você também pode passar argumentos variáveis por referência ao prefixar ... com um &.

Versões anteriores do PHP

Funções com argumentos variáveis não precisam de sintaxe específica. No entanto o acesso aos argumentos da função precisam utilizar. func_num_args(), func_get_arg() e func_get_args().

O primeiro exemplo acima seria implementado no PHP 5.5 e anteriores assim:

Exemplo #17 Acessando argumentos variáveis no PHP 5.5 e anteriores

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

echo 
sum(1234);
?>

O exemplo acima irá imprimir:

10

add a note add a note

User Contributed Notes 15 notes

up
94
php at richardneill dot org
6 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
31
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
15
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
1
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);
    }
}
?>
up
7
boan dot web at outlook dot com
3 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
12
jcaplan at bogus dot amazon dot com
15 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
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
5
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
5
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
7
Horst Schirmeier
7 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
2
catman at esteticas dot se
5 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
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
4
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
0
igorsantos07 at gmail dot com
3 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
-1
rsperduta at gmail dot com
2 months 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).
To Top