Information may be passed to functions via the argument list, which is a comma-delimited list of expressions. The arguments are evaluated from left to right, before the function is actually called [eager evaluation].
PHP supports passing arguments by value [the default], passing by reference, and default argument values. Variable-length argument lists and Named Arguments are also supported.
Example #1 Passing arrays to functions
functiontakes_array[$input]
{
echo"$input[0]+$input[1]=",$input[0]+$input[1];
}
?>
As of PHP 8.0.0, the list of function arguments may include a trailing comma, which will be ignored. That is particularly useful in cases where the list of arguments is long or contains long variable names, making it convenient to list arguments vertically.
Example #2 Function Argument List with trailing Comma
functiontakes_many_args[
$first_arg,
$second_arg,
$a_very_long_argument_name,
$arg_with_default=5,
$again='adefaultstring',//Thistrailingcommawasnotpermittedbefore8.0.0.
]
{
//...
}
?>
As of PHP 8.0.0, passing mandatory arguments after optional arguments is deprecated. This can generally be resolved by dropping the default value. One exception to this rule are arguments of the form Type $param = null, where the null default makes the type implicitly nullable. This usage remains allowed, though it is recommended to use an explicit nullable type instead.
Example #3 Passing optional arguments after mandatory arguments
functionfoo[$a=[],$b]{}//Before
functionfoo[$a,$b]{}//After
functionbar[A$a=null,$b]{}//Stillallowed
functionbar[?A$a,$b]{}//Recommended
?>
Passing arguments by reference
By default, function arguments are passed by value [so that if the value of the argument within the function is changed, it does not get changed outside of the function]. To allow a function to modify its arguments, they must be passed by reference.
To have an argument to a function always passed by reference, prepend an ampersand [&] to the argument name in the function definition:
Example #4 Passing function parameters by reference
functionadd_some_extra[&$string]
{
$string.='andsomethingextra.';
}
$str='Thisisastring,';
add_some_extra[$str];
echo$str;//outputs'Thisisastring,andsomethingextra.'
?>
It is an error to pass a value as argument which is supposed to be passed by reference.
Default argument values
A function may define C++-style default values for scalar arguments as follows:
Example #5 Use of default parameters in functions
functionmakecoffee[$type="cappuccino"]
{
return"Makingacupof$type.\n";
}
echomakecoffee[];
echomakecoffee[null];
echomakecoffee["espresso"];
?>
The above example will output:
PHP also allows the use of arrays and the special type null as default values, for example:
Example #6 Using non-scalar types as default values
functionmakecoffee[$types=array["cappuccino"],$coffeeMaker=NULL]
{
$device=is_null[$coffeeMaker]?"hands":$coffeeMaker;
return"Makingacupof".join[",",$types]."with$device.\n";
}
echomakecoffee[];
echomakecoffee[array["cappuccino","lavazza"],"teapot"];
?>
The default value must be a constant expression, not [for example] a variable, a class member or a function call.
Note that when using default arguments, any defaults should be on the right side of any non-default arguments; otherwise, things will not work as expected. Consider the following code snippet:
Example #7 Incorrect usage of default function arguments
functionmakeyogurt[$type="acidophilus",$flavour]
{
return"Makingabowlof$type$flavour.\n";
}
echomakeyogurt["raspberry"];//won'tworkasexpected
?>
The above example will output:
Now, compare the above with this:
Example #8 Correct usage of default function arguments
functionmakeyogurt[$flavour,$type="acidophilus"]
{
return"Makingabowlof$type$flavour.\n";
}
echomakeyogurt["raspberry"];//worksasexpected
?>
The above example will output:
Note: Arguments that are passed by reference may have a default value.
Variable-length argument lists
PHP has support for variable-length argument lists in user-defined functions by using the ... token.
Note: It is also possible to achieve variable-length arguments by using func_num_args[], func_get_arg[], and func_get_args[] functions. This technique is not recommended as it was used prior to the introduction of the ... token.
Argument lists may include the ... token to denote that the function accepts a variable number of arguments. The arguments will be passed into the given variable as an array; for example:
Example #9 Using ... to access variable arguments
functionsum[...$numbers]{
$acc=0;
foreach[$numbersas$n]{
$acc+=$n;
}
return$acc;
}
echosum[1,2,3,4];
?>
The above example will output:
... can also be used when calling functions to unpack an array or Traversable variable or literal into the argument list:
Example #10 Using ... to provide arguments
functionadd[$a,$b]{
return$a+$b;
}
echoadd[...[1,2]]."\n";
$a=[1,2];
echoadd[...$a];
?>
The above example will output:
You may specify normal positional arguments before the ... token. In this case, only the trailing arguments that don't match a positional argument will be added to the array generated by ....
It is also possible to add a type declaration before the ... token. If this is present, then all arguments captured by ... must match that parameter type.
Example #11 Type declared variable arguments
functiontotal_intervals[$unit,DateInterval...$intervals]{
$time=0;
foreach[$intervalsas$interval]{
$time+=$interval->$unit;
}
return$time;
}
$a=newDateInterval['P1D'];
$b=newDateInterval['P2D'];
echototal_intervals['d',$a,$b].'days';
//Thiswillfail,sincenullisn'taDateIntervalobject.
echototal_intervals['d',null];
?>
The above example will output:
Finally, variable arguments can also be passed by reference by prefixing the ... with an ampersand [&].
Older versions of PHP
No special syntax is required to note that a function is variadic; however access to the function's arguments must use func_num_args[], func_get_arg[] and func_get_args[].
The first example above would be implemented as follows in old versions of PHP:
Example #12 Accessing variable arguments in old PHP versions
functionsum[]{
$acc=0;
foreach[func_get_args[]as$n]{
$acc+=$n;
}
return$acc;
}
echosum[1,2,3,4];
?>
The above example will output:
Named Arguments
PHP 8.0.0 introduced named arguments as an extension of the existing positional parameters. Named arguments allow passing arguments to a function based on the parameter name, rather than the parameter position. This makes the meaning of the argument self-documenting, makes the arguments order-independent and allows skipping default values arbitrarily.
Named arguments are passed by prefixing the value with the parameter name followed by a colon. Using reserved keywords as parameter names is allowed. The parameter name must be an identifier, specifying dynamically is not allowed.
Example #13 Named argument syntax
myFunction[paramName:$value];
array_foobar[array:$value];
//NOTsupported.
function_name[$variableStoringParamName:$value];
?>
Example #14 Positional arguments versus named arguments
//Usingpositionalarguments:
array_fill[0,100,50];
//Usingnamedarguments:
array_fill[start_index:0,count:100,value:50];
?>
The order in which the named arguments are passed does not matter.
Example #15 Same example as above with a different order of parameters
array_fill[value:50,count:100,start_index:0];
?>
Named arguments can be combined with positional arguments. In this case, the named arguments must come after the positional arguments. It is also possible to specify only some of the optional arguments of a function, regardless of their order.
Example #16 Combining named arguments with positional arguments
htmlspecialchars[$string,double_encode:false];
//Sameas
htmlspecialchars[$string,ENT_QUOTES|ENT_SUBSTITUTE|ENT_HTML401,'UTF-8',false];
?>
Passing the same parameter multiple times results in an Error exception.
Example #17 Error exception when passing the same parameter multiple times
functionfoo[$param]{...}
foo[param:1,param:2];
//Error:Namedparameter$paramoverwritespreviousargument
foo[1,param:2];
//Error:Namedparameter$paramoverwritespreviousargument
?>