Informațiile pot fi transmise funcțiilor PHP prin lista de argumente, care este o listă de expresii delimitată prin virgulă. Argumentele sunt evaluate de la stânga la dreapta, înainte ca funcția să fie numită efectiv (evaluare eager).
PHP acceptă transmiterea argumentelor după valoare (implicita), trecerea prin referință și valorile argumentelor implicite. Listele de argumente cu lungime variabilă și argumentele denumite sunt, de asemenea, acceptate.
<?php
function
takes_array($input)
{
echo "$input[0]
+ $input[1]
= ",
$input[0]+$input[1];
}
?> Începând cu PHP 8.0.0, lista de argumente a funcției poate include o virgulă finală, care va fi ignorată. Acest lucru este util în special în cazurile în care lista de argumente este lungă sau conține nume lungi de variabile, ceea ce face convenabil să listați argumentele pe verticală.
Exemplul #2 Lista de argumente ale funcției cu virgulă finală
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.
<?php
function
takes_many_args(
$first_arg,
$second_arg,
$a_very_long_argument_name,
$arg_with_default
=
5,
$again
=
'un șir implicit',
// Această virgulă finală nu
a fost permisă înainte de 8.0.0.
)
{
// ...
}
?> Transmiterea argumentelor prin referință
În mod implicit, argumentele funcției sunt transmise după valoare (astfel încât, dacă valoarea argumentului din cadrul funcției este modificată, aceasta nu este modificată în afara funcției). Pentru a permite unei funcții să își modifice argumentele, acestea trebuie să fie transmise prin referință.
Pentru a avea un argument pentru o funcție transmis întotdeauna prin referință, adăugați un ampersand (&) la numele argumentului în definiția funcției:
Exemplul #3 Transmiterea parametrilor funcției prin referință
<?php
function
add_some_extra(&$string)
{
$string
.=
'și ceva în plus.';
}
$str
=
'Acesta este un șir, ';
add_some_extra($str);
echo $str;
// ieșire 'Acesta este
un șir, și ceva în plus.'
?> Este o eroare să treci o valoare ca argument care ar trebui să fie transmisă prin referință.
Valorile implicite ale argumentelor
O funcție poate defini valori implicite pentru argumente folosind o sintaxă similară cu alocarea unei variabile. Valoarea implicită este utilizată numai când parametrul nu este specificat; în special, rețineți că trecerea null nu atribuie valoarea implicită.
Exemplul #4 Utilizarea parametrilor impliciti în funcții
<?php
function
makecoffee($type
=
"cappuccino")
{
return "Making a
cup of
$type.\n";
}
echo makecoffee();
echo makecoffee(null);
echo makecoffee("espresso");
?>
Exemplul de mai sus va avea ieșirea:
Making a cup of cappuccino. Making a cup of . Making a cup of espresso.
Valorile implicite ale parametrilor pot fi valori scalare, matrice, tipul special null și, începând cu PHP 8.1.0, obiecte care utilizează noua sintaxă ClassName().
<?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");?>
<?php
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);
?> Valoarea implicită trebuie să fie o expresie constantă, nu (de exemplu) o variabilă, un membru al clasei sau un apel de funcție.
Rețineți că orice argument opțional trebuie specificat după orice argument necesar, altfel nu pot fi omise din apeluri. Luați în considerare următorul exemplu:
<?php
function
makeyogurt($container
=
"bowl",
$flavour)
{
return "Making a
$container
of $flavour
yogurt.\n";
}
echo makeyogurt("raspberry");
// "raspberry"
este
$container, nu $flavour
?>
Fatal error: Uncaught ArgumentCountError: Too few arguments to function makeyogurt(), 1 passed in example.php on line 42
Acum, comparași cele de mai sus cu aceasta:
<?php
function
makeyogurt($flavour,
$container
=
"bowl")
{
return "Making a
$container
of $flavour
yogurt.\n";
}
echo makeyogurt("raspberry");
// "raspberry"
este
$flavour
?>
Making a bowl of raspberry yogurt.
Începând cu PHP 8.0.0, argumentele numite pot fi folosite pentru a sări peste mai mulți parametri opționali.
<?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.
Începând cu PHP 8.0.0, declararea argumentelor obligatorii după argumentele opționale este depreciată. În general, acest lucru poate fi rezolvat prin eliminarea valorii implicite, deoarece nu va fi niciodată folosită. O excepție de la această regulă sunt argumentele de forma Type $param = null, unde implicitul
null
<?php
function
foo($a
= [],
$b)
{} // Implicit nu este
utilizat; depreciat începând cu PHP 8.0.0
function
foo($a,
$b)
{} // Echivalent din
punct de vedere funcțional, fără notificare de depreciere
function
bar(A
$a =
null,
$b)
{} // Încă permis; $a
este necesar, dar nulă
function
bar(?A
$a,
$b)
{} // Recomandat
?>
Notă: Începând cu PHP 7.1.0, omiterea unui parametru care nu specifică o valoare implicită generează un ArgumentCountError; în versiunile anterioare genera un Warning.
Notă: Argumentele care sunt transmise prin referință pot avea o valoare implicită.
Liste de argumente cu lungime variabilă
PHP are suport pentru liste de argumente cu lungime variabilă în funcțiile definite de utilizator prin utilizarea tokenului ….
Notă: Este, de asemenea, posibil să se obțină argumente cu lungime variabilă utilizând funcțiile func_num_args(), func_get_arg() și func_get_args(). Această tehnică nu este recomandată deoarece a fost folosită înainte de introducerea tokenului ….
Listele de argumente pot include tokenul … pentru a indica faptul că funcția acceptă un număr variabil de argumente. Argumentele vor fi trecute în variabila dată ca o matrice:
<?php
function
sum(...$numbers)
{
$acc
=
0;
foreach ($numbers
as
$n)
{
$acc
+=
$n;
}
return $acc;
}
echo sum(1,
2,
3,
4);
?>
10
... poate fi folosit și atunci când apelați funcții pentru a despacheta o matrice sau o variabilă Traversable sau un literal în lista de argumente:
... pentru a oferi argumente
<?php
function
add($a,
$b)
{
return $a
+
$b;
}
echo add(...[1,
2])."\n";
$a
= [1,
2];
echo add(...$a);
?>
3 3
Puteți specifica argumente poziționale normale înainte de tokenul .... În acest caz, numai argumentele de sfârșit care nu se potrivesc cu un argument pozițional vor fi adăugate la tabloul generat de ....
De asemenea, este posibil să adăugați o declarație de tip înainte de tokenul .... Dacă acesta este prezent, atunci toate argumentele capturate de ... trebuie să se potrivească cu acel tip de parametru.
<?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';
// Acest lucru va eșua,
deoarece null nu este un obiect DateInterval.
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
În cele din urmă, argumentele variabile pot fi transmise și prin referință prin prefixarea lui ... cu un ampersand (&).
Versiuni mai vechi de PHP ¶
Nu este necesară o sintaxă specială pentru a observa că o funcție este variadică; totuși accesul la argumentele funcției trebuie să utilizeze func_num_args(), func_get_arg() și func_get_args().
Primul exemplu de mai sus ar fi implementat după cum urmează în versiunile vechi de PHP:
<?php
function
sum()
{
$acc
=
0;
foreach (func_get_args()
as $n)
{
$acc
+=
$n;
}
return $acc;
}
echo sum(1,
2,
3,
4);
?>
10
Argumente numite
PHP 8.0.0 a introdus argumente numite ca o extensie a parametrilor poziționali existenți. Argumentele denumite permit transmiterea argumentelor unei funcții bazate pe numele parametrului, mai degrabă decât pe poziția parametrului. Acest lucru face ca sensul argumentului să se auto-documenteze, face ca argumentele să fie independente de ordine și permite sărirea în mod arbitrar a valorilor implicite.
Argumentele numite sunt transmise prin prefixarea valorii cu numele parametrului urmat de două puncte. Este permisă utilizarea cuvintelor cheie rezervate ca nume de parametri. Numele parametrului trebuie să fie un identificator, nu este permisă specificarea dinamică.
<?php
myFunction(paramName:
$value);
array_foobar(array:
$value);
// NU e suportat.
function_name($variableStoringParamName:
$value);
?>
<?php
// Folosind argumente
poziționale:
array_fill(0,
100,
50);
// Folosind argumente
numite:
array_fill(start_index:
0,
count:
100,
value:
50);
?>
Ordinea în care sunt transmise argumentele numite nu contează.
<?php
array_fill(value:
50,
count:
100,
start_index:
0);
?> Argumentele numite pot fi combinate cu argumente poziționale. În acest caz, argumentele numite trebuie să vină după argumentele poziționale. De asemenea, este posibil să se specifice doar unele dintre argumentele opționale ale unei funcții, indiferent de ordinea acestora.
<?php
htmlspecialchars($string,
double_encode:
false);
// La fel ca
htmlspecialchars($string,
ENT_QUOTES
|
ENT_SUBSTITUTE
|
ENT_HTML401,
'UTF-8',
false);
?> Trecerea aceluiași parametru de mai multe ori duce la o excepție de eroare.
<?php
function
foo($param)
{ ... }
foo(param:
1,
param:
2);
// Eroare: Parametrul
numit $param suprascrie argumentul anterior
foo(1,
param:
2);
// Eeroare: Parametrul
numit $param suprascrie argumentul anterior
?>
Începând cu PHP 8.1.0, este posibil să se utilizeze argumente numite după despachetarea argumentelor. Un argument numit nu trebuie să suprascrie un argument deja dezambalat.
<?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
?>
Sursa: PHP Manual, licența CC BY 3.0. Traducere și adaptare: Nicolae Sfetcu
Întreţinerea şi repararea calculatoarelor
Manual pentru începători pentru întreţinerea şi depanarea calculatoarelor, cu o introducere în noţiuni despre calculatoare, hardware, software (inclusiv sisteme de operare) şi securitatea pe Internet. Un calculator de uz general are patru componente principale: unitatea logică aritmetică (ALU), unitatea de … Citeşte mai mult
Analitica rețelelor sociale
Descoperă puterea datelor și transformă modul în care înțelegi și utilizezi rețelele sociale.
Căutarea, extragerea, organizarea și evaluarea informațiilor
Transformă informația în putere cu ajutorul acestei cărți indispensabile!
Lasă un răspuns