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".
*/
?>
Argomenti delle funzioni
L'informazione può essere passata alle funzioni tramite la lista degli argomenti, che sono liste di espressioni delimitati dalla virgola. Gli argomenti sono valutati da sinistra a destra, prima che la funzione venga effettivamente chiamata (valutazione eager).
PHP supporta il passaggio di argomenti per valore (comportamento di default), il passaggio per riferimento, e i valori di default degli argomenti. Le liste di argomenti di lunghezza varabile e i Named Arguments sono ugualmente supportati.
Example #1 Passaggio di array a funzioni
<?php
function prende_array($input)
{
echo "$input[0] + $input[1] = ", $input[0]+$input[1];
}
?>A partire da PHP 8.0.0, l'elenco degli argomenti della funzione può includere una virgola finale, che verrà ignorata. Ciò è particolarmente utile nei casi in cui l'elenco di argomenti è lungo o contiene nomi di variabili lunghi, rendendo conveniente elencare gli argomenti verticalmente.
Example #2 Elenco degli Argomenti della Funzione con Virgola finale
<?php
function takes_many_args(
$first_arg,
$second_arg,
$a_very_long_argument_name,
$arg_with_default = 5,
$again = 'a default string', // Questa virgola finale non era consentita prima della 8.0.0.
)
{
// ...
}
?>
A partire da PHP 8.0.0, dichiarare argomenti obbligatori dopo argomenti opzionali
è deprecato. Questo può essere generalmente risolto eliminando il valore predefinito.
Un'eccezione a questa regola sono gli argomenti nella forma
Type $param = null, dove il default null rende il tipo implicitamente
annullabile. Questo utilizzo rimane consentito, sebbene si consiglia di utilizzare invece
un tipo nullable esplicito.
Example #3 Dichiarazione di argomenti facoltativi dopo argomenti obbligatori
<?php
function foo($a = [], $b) {} // Prima
function foo($a, $b) {} // Dopo
function bar(A $a = null, $b) {} // Ancora consentito
function bar(?A $a, $b) {} // Consigliato
?>Passare argomenti per riferimento
Di default, gli argomenti della funzione sono passati per valore (così se cambiate il valore dell'argomento all'interno della funzione , esso non cambierà fuori della funzione). Se volete permettere ad una funzione di modificare i suoi argomenti, dovete passarli per riferimento.
Se volete che una argomento sia passato sempre per riferimento ad una funzione, dovete anteporre un ampersand (&) al nome dell'argomento nella definizione della funzione:
Example #4 Passaggio di parametri per riferimento
<?php
function aggiungi_qualcosa(&$string)
{
$string .= 'e qualche altra cosa.';
}
$str = 'Questa è una stringa, ';
aggiungi_qualcosa($str);
echo $str; // l'output sarà 'Questa è una stringa, e qualche altra cosa.'
?>È un errore passare un valore come argomento che dovrebbe essere passato per riferimento.
Valori predefiniti degli argomenti
Una funzione può definire valori predefiniti in stile C++ per argomenti scalari come segue:
Example #5 Utilizzo dei parametri default in una funzione
<?php
function fare_il_caffe($tipo = "cappuccino")
{
return "Sto facendo una tazza di $tipo.\n";
}
echo fare_il_caffe();
echo fare_il_caffe(null);
echo fare_il_caffe("espresso");
?>Il precedente esempio visualizzerà:
Sto facendo una tazza di cappuccino. Sto facendo una tazza di. Sto facendo una tazza di espresso.
Anche il PHP permette di utilizzare array ed il tipo speciale null
come valore di default, ad esempio:
Example #6 Utilizzo di tipi non scalari come valori di default
<?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");
?>Il valore predefinito deve essere un'espressione costante, non (per esempio) una variabile, un membro di classe o una chiamata ad una funzione.
Da notare che quando vengono usati argomenti predefiniti, qualunque argomento predefinito dovrebbe essere a destra degli argomenti non-predefiniti; diversamente, le cose non funzioneranno come ci si aspetti. Si consideri il seguente frammento di codice:
Example #7 Utilizzo incorretto degli argomenti di default
<?php
function fare_lo_yogurt($tipo = "yogurt", $gusto)
{
return "Fare una vaschetta di $tipo a $gusto.\n";
}
echo fare_lo_yogurt("fragola"); // non funziona come si aspetta
?>Il precedente esempio visualizzerà:
Warning: Missing argument 2 in call to fare_lo_yogurt() in /usr/local/etc/httpd/htdocs/phptest/functest.html on line 41 Fare una vaschetta di fragola a.
Ora, si confronti il codice di sopra con questo:
Example #8 Utilizzo corretto degli argomenti di default
<?php
function fare_lo_yogurt($gusto, $tipo = "yogurt")
{
return "Fare una vaschetta di $tipo a $gusto.\n";
}
echo fare_lo_yogurt("fragola"); // funziona come si aspetta
?>Il precedente esempio visualizzerà:
Fare una vaschetta di yogurt a fragola.
Nota: I parametri che sono passati per riferimento possono avere un valore di default.
Liste di argomenti a lunghezza variabile
PHP ha il supporto per le liste di argomenti a lunghezza variabile nelle
funzioni definite dall'utente utilizzando il
token ....
Nota: È anche possibile ottenere argomenti di lunghezza variabile utilizzando le funzioni func_num_args(), func_get_arg(), e func_get_args(). Questa tecnica è sconsigliata poiché era utilizzata prima dell'introduzione del token
....
Le liste dei parametri possono includere il token
... per denotare che la funzione accetta un
numero variabile di parametri. I parametri saranno passati nella
variabile data come un array; per esempio:
Example #9 Utilizzo di ... per accedere ai parametri variabili
<?php
function sum(...$numbers) {
$acc = 0;
foreach ($numbers as $n) {
$acc += $n;
}
return $acc;
}
echo sum(1, 2, 3, 4);
?>Il precedente esempio visualizzerà:
10
Si può anche usare ... quando vengono chiamate funzioni per spacchettare
un array o una variabile Traversable o
literal all'interno della lista degli argomenti:
Example #10 Uso di ... per fornire parametri
<?php
function add($a, $b) {
return $a + $b;
}
echo add(...[1, 2])."\n";
$a = [1, 2];
echo add(...$a);
?>Il precedente esempio visualizzerà:
3 3
Si possono specificare parametri con posizione normale prima del
token .... In questo caso, solo i parametri seguenti
che non corrispondono ad un parametro posizionale saranno aggiunti all'array
generato da ....
È anche possibile aggiungere una
dichiarazione di tipo prima del
token .... Se questa è presente, allora tutti i parametri
catturati da ... devono corrispondere a quel tipo di parametro.
Example #11 Parametri variabili con tipo dichiarato
<?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';
// Questo fallirà, dato che null non è un oggetto DateInterval.
echo total_intervals('d', null);
?>Il precedente esempio visualizzerà:
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
Infine, si possono anche passare parametri variabili
per riferimento
anteponendo ... con un ampersand
(&).
Versioni precedenti di PHP
Non è richiesta una sintassi speciale per annotare che una funzione è variadica; tuttavia per accedere ai parametri della funzione bisogna usare func_num_args(), func_get_arg() e func_get_args().
Il primo esempio di sopra sarebbe implementato come segue in vecchie versioni di PHP:
Example #12 Accesso ai parametri variabili in vecchie versioni di PHP
<?php
function sum() {
$acc = 0;
foreach (func_get_args() as $n) {
$acc += $n;
}
return $acc;
}
echo sum(1, 2, 3, 4);
?>Il precedente esempio visualizzerà:
10
Argomenti Nominali
PHP 8.0.0 ha introdotto argomenti nominali come estensione dei parametri posizionali esistenti. Gli argomenti nominali consentono di passare argomenti ad una funzione in base al nome del parametro, piuttosto che alla posizione del parametro. Ciò rende il significato dell'argomento auto-documentante, rende gli argomenti indipendenti dall'ordine e consente di saltare arbitrariamente i valori predefiniti.
Gli argomenti nominali vengono passati anteponendo al valore il nome del parametro seguito da due punti. È consentito l'utilizzo di parole chiave riservate come nomi di parametri. Il nome del parametro deve essere un identificatore, non è consentito specificarlo dinamicamente.
Example #13 Sintassi dell'argomento denominato
<?php
myFunction(paramName: $value);
array_foobar(array: $value);
// NON supportato.
function_name($variableStoringParamName: $value);
?>Example #14 Argomenti posizionali contro argomenti nominali
<?php
// Utilizzo di argomenti posizionali:
array_fill(0, 100, 50);
// Utilizzo di argomenti nominali:
array_fill(start_index: 0, count: 100, value: 50);
?>L'ordine in cui vengono passati gli argomenti nominali non ha importanza.
Example #15 Stesso esempio di sopra con un diverso ordine dei parametri
<?php
array_fill(value: 50, count: 100, start_index: 0);
?>Gli argomenti nominali possono essere combinati con argomenti posizionali. In questo caso, gli argomenti nominali devono venire dopo gli argomenti posizionali. È anche possibile specificare solo alcuni degli argomenti opzionali di una funzione, indipendentemente dal loro ordine.
Example #16 Combinazione di argomenti nominali con argomenti posizionali
<?php
htmlspecialchars($string, double_encode: false);
// Uguale a
htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, 'UTF-8', false);
?>Il passaggio multiplo dello stesso parametro genera un'eccezione Error.
Example #17 Eccezione Error durante il passaggio multiplo dello stesso parametro
<?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
?>
add a note
User Contributed Notes 14 notes
php at richardneill dot org ¶
9 years ago
Simmo at 9000 dot 000 ¶
2 years ago
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).
LilyWhite ¶
3 years ago
It is worth noting that you can use functions as function arguments
<?php
function 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:
3
2
tianyiw at vip dot qq dot com ¶
2 years ago
<?php
/**
* Create an array using Named Parameters.
*
* @param mixed ...$values
* @return array
*/
function arr(mixed ...$values): array
{
return $values;
}
$arr = arr(
name: 'php',
mobile: 123456,
);
var_dump($arr);
// array(2) {
// ["name"]=>
// string(3) "php"
// ["mobile"]=>
// int(123456)
// }
gabriel at figdice dot org ¶
8 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
?>
Hayley Watson ¶
7 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.
boan dot web at outlook dot com ¶
6 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
?>
Luna ¶
2 years ago
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:
<?php
function 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"; // Works
echo 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.
Sergio Santana: ssantana at tlaloc dot imta dot mx ¶
19 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.
jcaplan at bogus dot amazon dot com ¶
18 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
?>
catman at esteticas dot se ¶
8 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
Hayley Watson ¶
7 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.
info at keraweb dot nl ¶
7 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"
John ¶
18 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)
