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