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 est également supportée.
Exemple #1 Nombre variable d'arguments sous forme de tableau
<?php
function takes_array($input)
{
echo "$input[0] + $input[1] = ", $input[0]+$input[1];
}
?>
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 #2 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.'
?>
Vous pouvez définir comme en C++ des valeurs par défaut pour les arguments de type scalaire :
Exemple #3 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 #4 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 #5 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 #6 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: Depuis PHP 5, les arguments passés par référence peuvent avoir une valeur par défaut.
Note:
Les déclarations de type sont aussi connues sous le nom de "type hints" en PHP 5.
Les déclarations de type permettent aux fonctions de requérir que ertains paramètre soit d'un certain type lors de l'appel de celles ci. Si la valeur donnée est d'un type incorrect alors une erreur est générée : en PHP 5, cela sera une erreur fatale récupérable tandis que PHP 7 lévera une exception TypeError.
Pour spécifier une déclaration de type, le type doit être ajouté avant le
nom du paramètre. La déclaration peut accepter les valeurs NULL si la
valeur par défaut du paramètre est définie à NULL.
| Type | Description | Version PHP minimum |
|---|---|---|
| Nom de la Classe/interface | Le paramètre doit être une instanceof du la classe ou interface donnée. | PHP 5.0.0 |
| self | Le paramètre doit être une instanceof de la même classe qui a définie la méthode. Ceci ne peut être utilisé que sur les méthodes des classes et des instances. | PHP 5.0.0 |
| array | Le paramètre doit être un array. | PHP 5.1.0 |
| callable | Le paramètre doit être un callable valide. | PHP 5.4.0 |
| bool | Le paramètre doit être un boolean. | PHP 7.0.0 |
| float | Le paramètre doit être un nombre flottant (float). | PHP 7.0.0 |
| int | Le paramètre doit être un integer. | PHP 7.0.0 |
| string | Le paramètre doit être une string. | PHP 7.0.0 |
Utiliser des alias pour les types scalaires ci-dessus n'est pas supporté. A la place, ils sont traités comme noms de classe ou d'interface. Par exemple, utiliser boolean comme paramètre ou type retourné nécessite un argument ou une valeur retournée qui est une instanceof la classe ou l'interface boolean, plutôt que de type bool :
<?php
function test(boolean $param) {}
test(true);
?>
L'exemple ci-dessus va afficher :
Fatal error: Uncaught TypeError: Argument 1 passed to test() must be an instance of boolean, boolean given, called in - on line 1 and defined in -:1
Exemple #7 Déclaration basique de type de classe
<?php
class C {}
class D extends C {}
// Ceci n'étend pas C
class E {}
function f(C $c) {
echo get_class($c)."\n";
}
f(new C);
f(new D);
f(new E);
?>
L'exemple ci-dessus va afficher :
C
D
Fatal error: Uncaught TypeError: Argument 1 passed to f() must be an instance of C, instance of E given, called in - on line 14 and defined in -:8
Stack trace:
#0 -(14): f(Object(E))
#1 {main}
thrown in - on line 8
Exemple #8 Déclaration basique de type interface
<?php
interface I { public function f(); }
class C implements I { public function f() {} }
// Ceci n'implémente pas I.
class E {}
function f(I $i) {
echo get_class($i)."\n";
}
f(new C);
f(new E);
?>
L'exemple ci-dessus va afficher :
C
Fatal error: Uncaught TypeError: Argument 1 passed to f() must implement interface I, instance of E given, called in - on line 13 and defined in -:8
Stack trace:
#0 -(13): f(Object(E))
#1 {main}
thrown in - on line 8
Exemple #9 Déclaration de type avec valeur de type NULL
<?php
class C {}
function f(C $c = null) {
var_dump($c);
}
f(new C);
f(null);
?>
L'exemple ci-dessus va afficher :
object(C)#1 (0) {
}
NULL
Par défaut, PHP va convertir les mauvais types vers le type scalaire attendu tant que possible. Par exemple, une fonction, qui attend comme paramètre un integer (entier), a laquelle est passée une string (chaine de caractères) recevra une variable de type string.
Il est possible d'activer un typage strict fichier par fichier. Dans ce mode, seule une variable du type exact au type attendu dans la déclaration sera acceptée sinon une exception du type TypeError sera levée. La seule exception à cette règle est qu'un entier (integer) peut être passé à une fonction attendant un nombre flottant (float). Les appels aux fonctions depuis des fonctions internes ne seront pas affectés par la déclaration strict_types.
Pour activer le typage strict, l'expression declare est utilisée avec la déclaration strict_types :
L'activation du mode strict affecte également les déclarations de type retourné.
Note:
Le typage strict s'applique aux appels de fonction effectués depuis l'intérieur d'un fichier dont le typage strict est actif, et non aux fonctions déclarées dans ce fichier. Si un fichier dont le typage strict n'est pas activé effectue un appel à une fonction qui a été définie dans un fichier dont le type strict est actif, la préférence de l'appelant sera respecté, et la valeur sera forcée.
Note:
Le typage strict n'est défini que pour les déclarations de type scalaire ; aussi, il nécessite PHP 7.0.0 ou supérieur, sachant que les déclarations de type scalaire ont été ajoutés dans cette version.
Exemple #10 Typage strict
<?php
declare(strict_types=1);
function sum(int $a, int $b) {
return $a + $b;
}
var_dump(sum(1, 2));
var_dump(sum(1.5, 2.5));
?>
L'exemple ci-dessus va afficher :
int(3)
Fatal error: Uncaught TypeError: Argument 1 passed to sum() must be of the type integer, float given, called in - on line 9 and defined in -:4
Stack trace:
#0 -(9): sum(1.5, 2.5)
#1 {main}
thrown in - on line 4
Exemple #11 Typage faible
<?php
function sum(int $a, int $b) {
return $a + $b;
}
var_dump(sum(1, 2));
// Ceux-ci vont être forcés en entier: notez l'affichage ci-dessous !
var_dump(sum(1.5, 2.5));
?>
L'exemple ci-dessus va afficher :
int(3) int(3)
Exemple #12 Capturer l'exception de type TypeError
<?php
declare(strict_types=1);
function sum(int $a, int $b) {
return $a + $b;
}
try {
var_dump(sum(1, 2));
var_dump(sum(1.5, 2.5));
} catch (TypeError $e) {
echo 'Erreur : '.$e->getMessage();
}
?>
L'exemple ci-dessus va afficher :
int(3) Erreur : Argument 1 passed to sum() must be of the type integer, float given, called in - on line 10
PHP supporte les fonctions à nombre d'arguments variable. Ceci est implémenté en utilisant le mot clé ... en PHP 5.6 et suivants, et en utilisant les fonctions func_num_args(), func_get_arg() et func_get_args() en PHP 5.5 et antérieurs.
En PHP 5.6 et suivants, la liste des arguments peut inclure le mot clé ... 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 #13 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 :
10
Vous pouvez aussi utiliser le mot clé ... lors de l'appel aux fonctions pour extraire le tableau, la variable Traversable ou le litéral dans la liste d'arguments :
Exemple #14 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 :
3 3
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 #15 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 (&).
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 doit être implémenté comme ceci en PHP 5.5 et antérieurs :
Exemple #16 Accès aux arguments variables en PHP 5.5 et antérieurs
<?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 :
10