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, avant que la fonction soit
actuellement appelée (évaluation immédiate).
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.
)
{
// ...
}
?>
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 #3 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
Une fonction peut définir des valeurs par défaut pour les arguments en utilisant une syntaxe similaire à l'affectation d'une variable.
La valeur par défaut n'est utilisée que lorsque le paramètre n'est pas spécifié ;
en particulier, notez que le passage de null n'assigne pas la valeur par défaut.
Exemple #4 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.
Les valeurs par défaut des paramètres peuvent être des valeurs scalaires,
des tableaus, le type spécial null, et à partir de PHP 8.1.0,
des objets utilisant la syntaxe new ClassName().
Exemple #5 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");
?>
L'exemple ci-dessus va afficher :
Préparation d'une tasse de cappuccino avec les mains.
Préparation d'une tasse de cappuccino, lavazza avec une cafetière.
Exemple #6 Utilisation d'objets comme valeurs par défaut (à partir de PHP 8.1.0)
<?php
class DefaultCoffeeMaker {
public function brew() {
return 'Faire du café.\n';
}
}
class FancyCoffeeMaker {
public function brew() {
return 'Créer un beau café rien que pour vous.\n';
}
}
function makecoffee($coffeeMaker = new DefaultCoffeeMaker)
{
return $coffeeMaker->brew();
}
echo makecoffee();
echo makecoffee(new FancyCoffeeMaker);
?>
L'exemple ci-dessus va afficher :
Faire du café.
Créer un beau café rien que pour vous.
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 tous les arguments facultatifs doivent être spécifiés après les arguments obligatoires,
sinon ils ne peuvent pas être omis dans les appels.
Considérons le code suivant :
Exemple #7 Les arguments sans valeur par défaut doivent être en premiers : erreur
<?php
function faireunyaourt ($container = "bol", $flavour)
{
return "Préparer un $container de yaourt à la $flavour.\n";
}
echo faireunyaourt("framboise"); // "framboise" est $container, pas $flavour
?>
L'exemple ci-dessus va afficher :
Fatal error: Uncaught ArgumentCountError: Too few arguments
to function faireunyaourt(), 1 passed in example.php on line 42
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, $container = "bol")
{
return "Préparer un $container de yaourt à la $flavour.\n";
}
echo faireunyaourt ("framboise"); // "framboise" est $flavour
?>
L'exemple ci-dessus va afficher :
Préparer un bol de yaourt à la framboise.
À partir de PHP 8.0.0, les arguments nommés
peuvent être utilisées pour passer outre plusieurs paramètres optionnels.
Exemple #9 Utilisation correcte des arguments de fonction par défaut
<?php
function faireunyaourt($container = "bol", $flavour = "framboise", $style = "Grec")
{
return "Préparer un $container de yaourt $style à la $flavour.\n";
}
echo faireunyaourt(style: "naturel");
?>
L'exemple ci-dessus va afficher :
Préparer un bol de yaourt naturel à la framboise.
À partir de PHP 8.0.0, déclarer des arguments obligatoires après des arguments optionnels est obsolète.
Ce problème peut généralement être résolu en abandonnant la valeur par défaut, puisqu'elle ne sera jamais utilisée.
Une exception à cette règle concerne les arguments de la forme Type $param = null,
où le null par défaut rend le type implicitement nullable.
Cet usage est déprécié depuis PHP 8.4.0, et un
type nullable
explicite doit être utilisé à la place.
Exemple #10 Déclarer des arguments facultatifs après les arguments obligatoires
<?php
function foo($a = [], $b) {} // Valeur par défaut non utilisée ; déconseillée à partir de PHP 8.0.0
function foo($a, $b) {} // Fonctionnellement équivalent, pas d’avertissement de dépréciation
function bar(A $a = null, $b) {} // À partir de PHP 8.1.0, $a est implicitement requis
// (car il précède un paramètre requis),
// mais implicitement nullable (déconseillé à partir de PHP 8.4.0),
// car la valeur par défaut du paramètre est null
function bar(?A $a, $b) {} // Recommandé
?>
Note:
À partir de PHP 7.1.0, l'omission d'un paramètre qui ne spécifie pas une valeur par défaut lance
un ArgumentCountError ;
dans les versions précédentes, cela levait un avertissement.
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éfini par l'utilisateur en utilisant le 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:
Exemple #11 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 des appels de
fonctions pour extraire le tableau ou la variable
Traversable ou le littéral dans la liste d'arguments :
Exemple #12 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 une
déclaration de type
avant le jeton .... Si ceci est présent,
alors tous les arguments capturés par ...
doivent correspondre au type de paramètre.
Exemple #13 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
(&).
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 valeurs 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 #14 Syntaxe des arguments nommés
<?php
myFunction(paramName: $value);
array_foobar(array: $value);
// NON supporté.
function_name($variableStoringParamName: $value);
?>
Exemple #15 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 #16 Même exemple que ci-dessus, mais avec un ordre de paramètre différent
<?php
array_fill(value: 50, count: 100, start_index: 0);
?>
Les arguments nommés peuvent être combinés avec les arguments positionnels.
Auquel 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, peu importe leur ordre.
Exemple #17 Combiner les arguments nommés avec les arguments positionnels
<?php
htmlspecialchars($string, double_encode: false);
// Same as
htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, 'UTF-8', false);
?>
Passer le même paramètre plusieurs fois résulte en une Error exception.
Exemple #18 Error émise quand un même paramètre est passé 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
?>
À partir de PHP 8.1.0, il est possible d'utiliser des arguments nommés après avoir décompressé les arguments.
Un argument nommé ne doit pas écraser un argument déjà déballé.
Exemple #19 Utiliser les arguments nommés après le déballage
<?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)); // Erreur fatale. Le paramètre nommé $b écrase l'argument précédent.
?>
