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.
Example #1 Passing arrays to functions
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.
Example #2 Function Argument List with trailing Comma
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:
Example #3 Passing function parameters by reference
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.
Example #4 Use of default parameters in functions
function makecoffee($type = "cappuccino") < return "Making a cup of $type.\n"; > echo makecoffee(); echo makecoffee(null); echo makecoffee("espresso"); ?> The above example will output:
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.
Example #5 Using non-scalar types as default values
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");?> Example #6 Using objects as default values (as of PHP 8.1.0)
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); ?> 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:
Example #7 Incorrect usage of default function arguments
function makeyogurt($container = "bowl", $flavour) < return "Making a $container of $flavour yogurt.\n"; > echo makeyogurt("raspberry"); // "raspberry" is $container, not $flavour ?> The above example will output:
Fatal error: Uncaught ArgumentCountError: Too few arguments to function makeyogurt(), 1 passed in example.php on line 42
Now, compare the above with this:
Example #8 Correct usage of default function arguments
function makeyogurt($flavour, $container = "bowl") < return "Making a $container of $flavour yogurt.\n"; > echo makeyogurt("raspberry"); // "raspberry" is $flavour ?> The above example will output:
Making a bowl of raspberry yogurt. As of PHP 8.0.0, named arguments can be used to skip over multiple optional parameters.
Example #9 Correct usage of default function arguments
function makeyogurt($container = "bowl", $flavour = "raspberry", $style = "Greek") < return "Making a $container of $flavour $style yogurt.\n"; > echo makeyogurt(style: "natural"); ?> The above example will output:
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.
Example #10 Declaring optional arguments after mandatory arguments
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 ?> Note: 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.
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 #11 Using . to access variable arguments
function sum(. $numbers) < $acc = 0; foreach ($numbers as $n) < $acc += $n; > return $acc; > echo sum(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 #12 Using . to provide arguments
function add($a, $b) < return $a + $b; > echo add(. [1, 2])."\n"; $a = [1, 2]; echo add(. $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 #13 Type declared variable arguments
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); ?> The above example will output:
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 ( & ).
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 #14 Accessing variable arguments in old PHP versions
function sum( ) < $acc = 0; foreach (func_get_args() as $n) < $acc += $n; > return $acc; > echo sum(1, 2, 3, 4); ?> The above example will output:
Php functions pass arguments
To experiment on performance of pass-by-reference and pass-by-value, I used this script. Conclusions are below.
#!/usr/bin/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
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)
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».
*/
?>