To experiment on performance of pass-by-reference and pass-by-value, I used this  script. Conclusions are below. #!/usr/bin/php<?phpfunction 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 us2    reference  no          58 us3    valuue     yes         129 s4    reference  yes         66 usConclusions: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".*/?>

For anyone just getting started with php or searching, for an understanding, on what this page describes as a "... token" in Variable-length arguments:https://www.php.net/manual/en/functions.arguments.php#functions.variable-arg-list<?php  func($a, ...$b) ?>The 3 dots, or elipsis, or "...", or dot dot dot is sometimes called the "spread operator" in other languages.As this is only used in function arguments, it is probably not technically an true operator in PHP.  (As of 8.1 at least?).(With having an difficult to search for name like "... token", I hope this note helps someone).

It is worth noting that you can use functions as function arguments<?phpfunction run($op, $a, $b) {  return $op($a, $b);}$add = function($a, $b) {  return $a + $b;};$mul = function($a, $b) {  return $a * $b;};echo run($add, 1, 2), "\n";echo run($mul, 1, 2);?>Output:32

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

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.

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+):<?phpfunction foo(?string $bar) {    //...}foo(); // Fatal errorfoo(null); // Okayfoo('Hello world'); // Okay?>

When using named arguments and adding default values only to some of the arguments, the arguments with default values must be specified at the end or otherwise PHP throws an error:<?phpfunction test1($a, $c, $b = 2){    return $a + $b + $c;}function test2($a, $b = 2, $c){    return $a + $b + $c;}echo test1(a: 1, c: 3)."\n"; // Worksecho test2(a: 1, c: 3)."\n"; // ArgumentCountError: Argument #2 ($b) not passed?>I assume that this happens because internally PHP rewrites the calls to something like test1(1, 3) and test2(1, , 3). The first call is valid, but the second obviously isn't.

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).<?phpfunction 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.