Les arguments de fonction
Des informations peuvent être passées à
une fonction en utilisant une liste d'arguments, dont chaque
expression est séparée par une virgule. Les arguments seront
évalués depuis la gauche vers la droite.
PHP supporte le passage d'arguments par valeur (comportement par défaut), le passage par référence, et des valeurs d'arguments par défaut.
Une liste variable d'arguments,
ainsi que les Arguments Nommés
sont également supportés.
Exemple #1 Nombre variable d'arguments sous forme de tableau
<?php
function takes_array($input)
{
echo "$input[0] + $input[1] = ", $input[0]+$input[1];
}
?>
À partir de PHP 8.0.0, la liste des arguments de fonction peut inclure une
virgule trainante, qui sera ignoré. Ceci est particulièrement pratique dans
les cas où la liste d'arguments est longue ou contient des noms de variables
longs, le rendant pratique pour lister les arguments verticalement.
Exemple #2 Function Argument List with trailing Comma
<?php
function takes_many_args(
$first_arg,
$second_arg,
$a_very_long_argument_name,
$arg_with_default = 5,
$again = 'a default string', // Cette virgule trainant n'était pas permit avant 8.0.0.
)
{
// ...
}
?>
À partir de PHP 8.0.0, passer des arguments obligatoire après des arguments optionnel
est obsolète. Ceci peut être généralement résolue en supprimant la valeur par défaut.
Une exception à cette règle sont les arguments de la forme
Type $param = null
, où le null
par défaut rend le type implicitement
nullable. Cette usage continue d'être autorisé, néanmoins il est recommandé d'utiliser
un type nullable explicitement à la place.
Exemple #3 Passer des arguments optionnels après des arguments obligatoire
<?php
function foo($a = [], $b) {} // Avant
function foo($a, $b) {} // Après
function bar(A $a = null, $b) {} // Toujours autorisé
function bar(?A $a, $b) {} // Recommandé
?>
Passage d'arguments par référence
Par défaut, les arguments sont passés
à la fonction par valeur (aussi, changer la valeur d'un argument dans la fonction ne
change pas sa valeur à l'extérieur de la fonction). Si vous voulez que vos fonctions
puissent changer la valeur des arguments, vous devez passer ces arguments par référence.
Si vous voulez qu'un argument soit toujours passé
par référence, vous pouvez ajouter un '&
'
devant l'argument dans la déclaration de la fonction :
Exemple #4 Passage d'arguments par référence
<?php
function add_some_extra(&$string)
{
$string .= ', et un peu plus.';
}
$str = 'Ceci est une chaîne';
add_some_extra($str);
echo $str; // Affiche : 'Ceci est une chaîne, et un peu plus.'
?>
C'est une erreur de passer une valeur en tant qu'argument qui est supposé d'être passé par référence.
Valeur par défaut des arguments
Vous pouvez définir comme en C++ des valeurs par
défaut pour les arguments de type scalaire :
Exemple #5 Valeur par défaut des arguments de fonctions
<?php
function servir_cafe ($type = "cappuccino")
{
return "Servir un $type.\n";
}
echo servir_cafe();
echo servir_cafe(null);
echo servir_cafe("espresso");
?>
L'exemple ci-dessus va afficher :
Servir un cappuccino.
Servir un .
Servir un espresso.
PHP vous autorise à utiliser des tableau ainsi que le type spécial
null
comme valeur par défaut, par exemple :
Exemple #6 Utilisation de type non scalaire comme valeur par défaut
<?php
function servir_cafe($types = array("cappuccino"), $coffeeMaker = NULL)
{
$device = is_null($coffeeMaker) ? "les mains" : $coffeeMaker;
return "Préparation d'une tasse de ".join(", ", $types)." avec $device.\n";
}
echo servir_cafe();
echo servir_cafe(array("cappuccino", "lavazza"), "une cafetière");
?>
La valeur par défaut d'un argument doit
obligatoirement être une constante, et ne peut être
ni une variable, ni un membre de classe, ni un appel de fonction.
Il est à noter que si vous utilisez des arguments avec
valeur par défaut avec d'autres sans valeur par défaut,
les premiers doivent être placés à la suite de tous les paramètres sans
valeur par défaut. Sinon, cela ne fonctionnera pas.
Considérons le code suivant :
Exemple #7 Les arguments sans valeur par défaut doivent être en premiers : erreur
<?php
function faireunyaourt ($type = "acidophilus", $flavour)
{
return "Préparer un bol de $type $flavour.\n";
}
echo faireunyaourt("framboise"); // ne fonctionne pas comme voulu
?>
L'exemple ci-dessus va afficher :
Warning: Missing argument 2 in call to faireunyaourt() in
/usr/local/etc/httpd/htdocs/phptest/functest.html on line 41
Préparer un bol de framboise .
Maintenant comparons l'exemple précédent avec l'exemple suivant :
Exemple #8 Les arguments sans valeur par défaut doivent être en premiers : valide
<?php
function faireunyaourt ($flavour, $type = "acidophilus")
{
return "Préparer un bol de $type $flavour.\n";
}
echo faireunyaourt ("framboise"); // fonctionne comme voulu
?>
L'exemple ci-dessus va afficher :
Préparer un bol de acidophilus framboise.
Note:
Les arguments passés par référence peuvent avoir
une valeur par défaut.
Liste d'argument à nombre variable
PHP supporte les arguments à nombre variable dans les
fonctions définie par l'utilisateur en utilisant le token
...
.
Note:
Il est aussi possible d'accomplir les arguments à nombre variable
en utilisant les fonctions func_num_args(),
func_get_arg(), et func_get_args().
Cette technique n'est pas recommandé car elle était utilisé antérieur à
l'introduction du token ...
.
La liste des arguments peut inclure le
token ...
pour indiquer que cette fonction accepte
un nombre variable d'arguments. Les arguments seront passés dans la variable
fournie sous forme d'un tableau ; par exemple :
Exemple #9 Utilisation de ...
pour accéder aux arguments variables
<?php
function sum(...$numbers) {
$acc = 0;
foreach ($numbers as $n) {
$acc += $n;
}
return $acc;
}
echo sum(1, 2, 3, 4);
?>
L'exemple ci-dessus va afficher :
...
peut aussi être utilisé lors de l'appels de
fonctions pour extraire le tableau ou la variable
Traversable ou le littéral dans la liste d'arguments :
Exemple #10 Utilisation de ...
pour fournir des arguments
<?php
function add($a, $b) {
return $a + $b;
}
echo add(...[1, 2])."\n";
$a = [1, 2];
echo add(...$a);
?>
L'exemple ci-dessus va afficher :
Vous pouvez spécifier des arguments classiques avant le mot clé
...
. Dans ce cas, seuls les arguments finaux
qui ne correspondent pas à un argument classique seront ajoutés
au tableau généré par ...
.
Il est également possible d'ajouter un
transtypage
avant le mot clé ...
. Si ce transtypage est présent,
alors tous les arguments capturés par ...
seront des objets de la classe visée.
Exemple #11 Transtypage d'arguments variables
<?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).' jours';
// Ceci échouera, car null n'est pas un objet DateInterval.
echo total_intervals('d', null);
?>
L'exemple ci-dessus va afficher :
3 jours
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
Pour finir, vous pouvez passer des arguments variables
par référence
en préfixant le mot clé ...
d'un ET commercial
(&
).
Les anciennes versions de PHP
Aucune syntaxe spéciale n'est nécessaire pour spécifier qu'une fonction
est variable ; cependant, l'accès aux arguments de la fonction
nécessite l'utilisation des fonctions
func_num_args(), func_get_arg()
et func_get_args().
Le premier exemple ci-dessus serait implémenté comme ceci pour
des anciennes versions de PHP
Exemple #12 Accès aux arguments variables dans des anciennes version de PHP
<?php
function sum() {
$acc = 0;
foreach (func_get_args() as $n) {
$acc += $n;
}
return $acc;
}
echo sum(1, 2, 3, 4);
?>
L'exemple ci-dessus va afficher :
Arguments Nommés
PHP 8.0.0 introduit les arguments nommés comme extension aux paramètres
positionnels existant. Les arguments nommés permettent de passer les
arguments à une fonction en s'appuyant sur le nom du paramètre, au lieu de
la position du paramètre. Ceci documente automatiquement la signification
de l'argument, rend l'ordre des arguments indépendant et permet d'ignorer
les valeur par défaut arbitrairement.
Les arguments nommés sont passés en préfixant la valeur avec le nom du
paramètre suivit d'un deux-points. Utiliser des mots-clés réservés comme
nom de paramètre est autorisé. Le nom du paramètre doit être un identifiant,
le spécifiant de façon dynamique n'est pas permis.
Exemple #13 Syntaxe des arguments nommés
<?php
myFunction(paramName: $value);
array_foobar(array: $value);
// NON supporté.
function_name($variableStoringParamName: $value);
?>
Exemple #14 Arguments positionnels comparés aux arguments nommés
<?php
// Utilisant les arguments positionnels :
array_fill(0, 100, 50);
// Utilisant les arguments nommés :
array_fill(start_index: 0, count: 100, value: 50);
?>
L'ordre dans lequel les arguments nommés sont passés n'importe pas.
Exemple #15 Même example que ci-dessus mais avec un ordre de paramètre différent
<?php
array_fill(value: 50, num: 100, start_index: 0);
?>
Les arguments nommés peuvent être combinés avec les arguments positionnels.
Au quel cas, les arguments nommés doivent venir après les arguments positionnels.
Il est aussi possible de spécifier seulement certains des arguments optionnels
d'une fonction, peut importe leur ordre.
Exemple #16 Combiner les arguments nommés avec les arguments positionnels
<?php
htmlspecialchars($string, double_encode: false);
// Same as
htmlspecialchars($string, ENT_COMPAT | ENT_HTML401, 'UTF-8', false);
?>
Passer le même paramètre plusieurs fois résulte en une Error exception.
Exemple #17 Exception Error quand un même paramètre est passer plusieurs fois
<?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
?>