17.controler Le Passage Des Arguments

Dans la leçon précédente, nous avons défini ce qu’était une fonction et vu comment
utiliser les fonctions internes au PHP ou comment créer et utiliser nos propres
fonctions.
Nous avons également compris la différence entre paramètre et argument et pourquoi
certaines fonctions avaient besoin qu’on leur passe des arguments pour fonctionner
correctement.
Dans cette leçon, nous allons aller plus loin et apprendre notamment à définir une
valeur par défaut pour nos arguments, à passer nos arguments par référence et à faire
des déclarations de type.
Passer des arguments par référence

Jusqu’à présent, nous avons passé nos arguments par valeur à nos fonctions ce qui
correspond au passage par défaut en PHP.
Lorsqu’on passe une variable comme argument par valeur à une fonction, le fait de
modifier la valeur de la variable à l’intérieur de la fonction ne va pas modifier sa valeur
à l’extérieur de la fonction.
Imaginons par exemple qu’on crée une fonction donc le rôle est d’ajouter 3 à la valeur
d’un argument. Notre fonction va ressembler à cela :
<!DOCTYPE html>
<html>
<head>
<title>Cours PHP & MySQL</title>
<meta charset="utf-8">
<link rel="stylesheet" href="cours.css">
</head>
<body>
<h1>Titre principal</h1>
<?php
$x = 0;
function plus3($p){
$p = $p + 3;
echo 'Valeur dans la fonction : ' .$p;
}
plus3($x);
echo '<br>Valeur en dehors de la fonction : ' .$x;
?>
<p>Un paragraphe</p>
</body>
</html>
Ici, on a défini une variable $x = 0 en dehors de notre fonction puis on a passé $x en

argument de notre fonction.
Notre fonction va ajouter 3 à la valeur de $x et echo le résultat.
Cependant, à l’extérieur de la fonction, notre variable $x va toujours stocker 0. On peut

s’en assurer en affichant la valeur de la variable hors fonction avec echo.
Parfois, on voudra cependant que nos fonctions puissent modifier la valeur des
variables qu’on leur passe en argument. Pour cela, il va falloir passer ces arguments par
référence.
Pour indiquer qu’on souhaite passer un argument par référence à une fonction, il suffit
d’ajouter le signe & devant le paramètre en question dans la définition de la liste des
paramètres de la fonction.
Comme vous pouvez le voir, en passant notre argument par référence, la fonction peut
modifier la valeur de celui-ci et cette valeur sera conservée dans le reste du script.
Définir des valeurs par défaut pour les
paramètres de nos fonctions
Le PHP va également nous permettre de définir une valeur par défaut pour un
paramètre d’une fonction. Cette valeur sera utilisée si aucun argument n’est fourni lors
de l’appel de la fonction.
Notez ici que la valeur par défaut doit obligatoirement être une valeur constante et ne
peut pas être une variable.
Notez également que si on définit une fonction avec plusieurs paramètres et qu’on
choisit de donner des valeurs par défaut à seulement certains d’entre eux, alors il faudra
placer les paramètres qui ont une valeur par défaut après ceux qui n’en possèdent pas
dans la définition de la fonction.
Dans le cas contraire, le PHP renverra une erreur et notre fonction ne pourra pas être
exécutée.
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<?php
function bonjour($prenom, $role='abonné(e)'){
echo 'Bonjour ' .$prenom. ' vous êtes un(e) ' .$role. '.<br>';
}
bonjour('Mathilde');
bonjour('Pierre', 'administrateur');
?>
</body>
</html>
Créer une fonction avec un nombre de
paramètres variables
Nous allons encore pouvoir définir des fonctions qui vont pouvoir accepter un nombre
variable d’arguments en valeurs.
Pour cela, il suffit d’ajouter … avant la liste des paramètres dans la définition de la
fonction pour indiquer que la fonction pourra recevoir un nombre d’arguments
variable.
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<?php
function bonjour(...$prenoms){
foreach($prenoms as $p){
echo 'Bonjour ' .$p. '<br>';
}
}
bonjour('Mathilde', 'Pierre', 'Victor');
?>
</body>
</html>
Cette syntaxe va créer un tableau avec nos différents arguments. Je dois donc utiliser
une boucle foreach pour parcourir mon tableau. Nous étudierons cela plus tard. Pour le
moment, contentez-vous de retenir cette syntaxe avec … avant la définition du
paramètre dans notre fonction.
Le PHP, un langage au typage faible

Une autre chose importante que vous devez savoir à propos du langage PHP est que
le PHP est un langage qui ne possède pas un typage fort (on parle de « loosely typed
language » en anglais).
Cela signifie de manière concrète qu’on n’a pas besoin de spécifier le type de données
attendues lorsqu’on définit des paramètres pour une fonction car le PHP va déterminer
lui-même le type des données passées à notre fonction en fonction de leur valeur.
Une conséquence de cela est qu’il va être possible de passer des arguments qui n’ont
aucun sens à une fonction sans déclencher d’erreur.
On va par exemple pouvoir parfaitement passer deux chaines de caractères à notre
fonction addition() créée dans la leçon précédente sans déclencher d’erreur.
Le typage des arguments

Depuis sa dernière version majeure (PHP7), le PHP nous offre néanmoins la possibilité
de préciser le type de données attendues lorsqu’on définit une fonction. Si une donnée
passée ne correspond pas au type attendu, le PHP essaiera de la convertir dans le bon
type et s’il n’y arrive pas une erreur sera cette fois-ci renvoyée.
Cela va permettre à nos fonctions de ne s’exécuter que si les valeurs passées en

argument sont valides et donc d’obtenir toujours un résultat cohérent par rapport à
nos attentes.
Les types valides sont les suivants :
Type Définition
string L’argument passé doit être de type string (chaine de caractères)
int L’argument passé doit être de type integer (nombre entier)
float L’argument passé doit être de type float ou double (nombre décimal)
bool L’argument passé doit être de type boolean (booléen)
array L’argument passé doit être de type array (tableau)
L’argument passé doit être de type array (tableau) ou une instance de

iterable
l’interface Traversable
callable L’argument passé doit être de type callable (fonction de rappel)

Type Définition
Nom de classe / L’argument passé doit être une instance de la classe ou de l’interface
d’interface donnée
L’argument passé doit être une instance de la même classe qui a défini
self
la méthode
object L’argument passé doit être de type object (objet)
Certains types nous sont encore inconnus, nous les étudierons plus tard dans ce cours.
Concentrez-vous pour le moment sur les types connus, à savoir string, int, float et bool.
Voici comment on va pouvoir utiliser les déclarations de type concrètement avec nos
fonctions :
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<?php
function test($a, $b){
echo $a. ' + ' .$b. ' = ' .($a + $b). '<br>';
}
function addition(float $a, float $b){
echo $a. ' + ' .$b. ' = ' .($a + $b). '<br>';
}
test(3, 4);
test(3, '4Pierre');//'4Pierre' est converti en 4 par PHP
test(3, 'Pierre');//'Pierre' est converti en 0 par PHP
addition(3, 4);
addition(3, 4.5);
addition(3.5, 4.2);
addition(3, '4Pierre');//'4Pierre' est converti en 4 par PHP
addition(3, 'Pierre');//Renvoie une erreur qui termine l'exécution
//Nous étudierons les erreurs plus tard dans le cours
echo 'Ce message ne s\'affichera pas ';
?>
</body>
</html>
Ici, l’utilisation de l’opérateur arithmétique + fait que PHP va convertir les valeurs à
gauche et à droite de l’opérateur en nombres. Si le PHP doit convertir une chaine de
caractères, il va regarder si un nombre se situe au début de celle-ci. Si c’est le cas, il
conserve le nombre. Sinon, la chaine sera évaluée à 0.
Notre deuxième fonction utilise le typage : on demande que les arguments fournis
soient de type float (nombres décimaux). Ici, si le PHP n’arrive pas à convertir les
arguments passés vers le type attendu, une erreur va être reournée.
Le typage strict
Nous allons pouvoir aller entre plus loin et activer un typage strict pour nos fonctions.
En utilisant le mode strict, les fonctions ne vont plus accepter que des arguments dont
le type correspond exactement au type demandé dans leur définition.
Notez ici que l’ensemble des nombres entiers fait partie de l’ensemble des nombres
décimaux. Ainsi, si on passe un nombre entier en argument d’une fonction qui attend
d’après sa définition un nombre décimal, la fonction s’exécutera normalement même
avec le mode strict activé.
Pour activer le typage strict, nous allons utiliser la structure de contrôle declare qui sert
à ajouter des directives d’exécution dans un bloc de code.
Nous allons pouvoir passer trois directives différentes à declare :
 La directive ticks ;
 La directive encoding ;
 La directive strict_types.
La directive qui va nous intéresser ici est strict_types. Pour activer le mode strict, nous
écrirons declare(strict_types= 1). Afin que le typage strict soit activé, il faudra
que declare(strict_types= 1) soit la première déclaration de notre fichier.
<?php declare(strict_types= 1);?>

<!DOCTYPE html>
<html>
<head>
</head>
<body>
<?php
function addition(float $a, float $b){
echo $a. ' + ' .$b. ' = ' .($a + $b). '<br>';
}
addition(3, 4);
addition(3, 4.5);
addition(3.5, 4.2);
addition(3, '4Pierre');//Ne fonctionne pas car typage strict activé
?>
</body>
</html>
Faites bien attention ici : le typage strict ne va s’appliquer que s’il est activé dans le
fichier depuis lequel la fonction est appelée. Ainsi, si vous définissez une fonction dans
un premier fichier qui possède le typage strict activé puis que vous appelez cette
fonction dans un autre fichier qui ne possède pas le typage strict activé, le typage strict
ne s’appliquera pas.
Notez également que le typage strict ne s’applique que pour les déclarations de type
scalaire, c’est-à-dire pour les types string, int, float et bool.

17.controler Le Passage Des Arguments

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

17.controler Le Passage Des Arguments

Transféré par

Droits d'auteur :

Formats disponibles

Dans la leçon précédente, nous avons défini ce qu’était une fonction et vu comment

Passer des arguments par référence

Ici, on a défini une variable $x = 0 en dehors de notre fonction puis on a passé $x en

Notre fonction va ajouter 3 à la valeur de $x et echo le résultat.

Cependant, à l’extérieur de la fonction, notre variable $x va toujours stocker 0. On peut

Le PHP, un langage au typage faible

Le typage des arguments

Cela va permettre à nos fonctions de ne s’exécuter que si les valeurs passées en

Les types valides sont les suivants :

string L’argument passé doit être de type string (chaine de caractères)

int L’argument passé doit être de type integer (nombre entier)

bool L’argument passé doit être de type boolean (booléen)

array L’argument passé doit être de type array (tableau)

L’argument passé doit être de type array (tableau) ou une instance de

callable L’argument passé doit être de type callable (fonction de rappel)

object L’argument passé doit être de type object (objet)

Nous allons pouvoir passer trois directives différentes à declare :

<?php declare(strict_types= 1);?>

Vous aimerez peut-être aussi