Function arguments
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.
Приклад #1 Passing arrays to functions
<?php
function takes_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.
Приклад #2 Function Argument List with trailing Comma
<?php
function takes_many_args(
$first_arg,
$second_arg,
$a_very_long_argument_name,
$arg_with_default = 5,
$again = 'a default string', // This trailing comma was not permitted before 8.0.0.
)
{
// ...
}
?>
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:
Приклад #3 Passing function parameters by reference
<?php
function add_some_extra(&$string)
{
$string .= 'and something extra.';
}
$str = 'This is a string, ';
add_some_extra($str);
echo $str; // outputs 'This is a string, and something extra.'
?>
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 default values for arguments using syntax similar
to assigning a variable. The default is used only when the parameter is
not specified; in particular, note that passing null does not
assign the default value.
Приклад #4 Use of default parameters in functions
<?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.
Default parameter values may be scalar values, arrays,
the special type null, and as of PHP 8.1.0, objects using the
new ClassName() syntax.
Приклад #5 Using non-scalar types as default values
<?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");?>
Поданий вище приклад
виведе:
Making a cup of cappuccino with hands.
Making a cup of cappuccino, lavazza with teapot.
Приклад #6 Using objects as default values (as of PHP 8.1.0)
<?php
class DefaultCoffeeMaker {
public function brew() {
return "Making coffee.\n";
}
}
class FancyCoffeeMaker {
public function brew() {
return "Crafting a beautiful coffee just for you.\n";
}
}
function makecoffee($coffeeMaker = new DefaultCoffeeMaker)
{
return $coffeeMaker->brew();
}
echo makecoffee();
echo makecoffee(new FancyCoffeeMaker);
?>
Поданий вище приклад
виведе:
Making coffee.
Crafting a beautiful coffee just for you.
The default value must be a constant expression, not (for
example) a variable, a class member or a function call.
Note that any optional arguments should be specified after any
required arguments, otherwise they cannot be omitted from calls.
Consider the following example:
Приклад #7 Incorrect usage of default function arguments
<?php
function makeyogurt($container = "bowl", $flavour)
{
return "Making a $container of $flavour yogurt.\n";
}
echo makeyogurt("raspberry"); // "raspberry" is $container, not $flavour
?>
Поданий вище приклад
виведе:
Fatal error: Uncaught ArgumentCountError: Too few arguments
to function makeyogurt(), 1 passed in example.php on line 42
Now, compare the above with this:
Приклад #8 Correct usage of default function arguments
<?php
function makeyogurt($flavour, $container = "bowl")
{
return "Making a $container of $flavour yogurt.\n";
}
echo makeyogurt("raspberry"); // "raspberry" is $flavour
?>
Поданий вище приклад
виведе:
Making a bowl of raspberry yogurt.
As of PHP 8.0.0, named arguments
can be used to skip over multiple optional parameters.
Приклад #9 Correct usage of default function arguments
<?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.
As of PHP 8.0.0, declaring mandatory arguments after optional arguments
is deprecated. This can generally be resolved by
dropping the default value, since it will never be used.
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.
Приклад #10 Declaring optional arguments after mandatory arguments
<?php
function foo($a = [], $b) {} // Default not used; deprecated as of PHP 8.0.0
function foo($a, $b) {} // Functionally equivalent, no deprecation notice
function bar(A $a = null, $b) {} // Still allowed; $a is required but nullable
function bar(?A $a, $b) {} // Recommended
?>
Зауваження:
As of PHP 7.1.0, omitting a parameter which does not specify a default
throws an ArgumentCountError; in previous versions
it raised a Warning.
Зауваження:
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.
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:
Приклад #11 Using ... to access variable arguments
<?php
function sum(...$numbers) {
$acc = 0;
foreach ($numbers as $n) {
$acc += $n;
}
return $acc;
}
echo sum(1, 2, 3, 4);
?>
Поданий вище приклад
виведе:
... can also be used when calling functions to unpack
an array or Traversable variable or
literal into the argument list:
Приклад #12 Using ... to provide arguments
<?php
function add($a, $b) {
return $a + $b;
}
echo add(...[1, 2])."\n";
$a = [1, 2];
echo add(...$a);
?>
Поданий вище приклад
виведе:
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.
Приклад #13 Type declared variable arguments
<?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';
// This will fail, since null isn't a DateInterval object.
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
Finally, variable arguments can also be passed
by reference by
prefixing the ... with an ampersand
(&).
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.
Приклад #14 Named argument syntax
<?php
myFunction(paramName: $value);
array_foobar(array: $value);
// NOT supported.
function_name($variableStoringParamName: $value);
?>
Приклад #15 Positional arguments versus named arguments
<?php
// Using positional arguments:
array_fill(0, 100, 50);
// Using named arguments:
array_fill(start_index: 0, count: 100, value: 50);
?>
The order in which the named arguments are passed does not matter.
Приклад #16 Same example as above with a different order of parameters
<?php
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.
Приклад #17 Combining named arguments with positional arguments
<?php
htmlspecialchars($string, double_encode: false);
// Same as
htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, 'UTF-8', false);
?>
Passing the same parameter multiple times results in an Error exception.
Приклад #18 Error thrown when passing the same parameter multiple times
<?php
function foo($param) { ... }
foo(param: 1, param: 2);
// Error: Named parameter $param overwrites previous argument
foo(1, param: 2);
// Error: Named parameter $param overwrites previous argument
?>
As of PHP 8.1.0, it is possible to use named arguments after unpacking the arguments.
A named argument must not override an already unpacked argument.
Приклад #19 Use named arguments after unpacking
<?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. Named parameter $b overwrites previous argument
?>
