Contrôler 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.

On passe des arguments à notre fonction PHP personnalisée par valeur

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.

On passe les arguments de notre fonction PHP par référence

Les arguments ont bien été passés par référence à notre fonction PHP

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>
        <title>Cours PHP & MySQL</title>
        <meta charset="utf-8">
        <link rel="stylesheet" href="cours.css">
    </head>
    
    <body>
        <h1>Titre principal</h1>
        <?php 
            function bonjour($prenom, $role='abonné(e)'){
                echo 'Bonjour ' .$prenom. ' vous êtes un(e) ' .$role. '.<br>';
            }
            
            bonjour('Mathilde');
            bonjour('Pierre', 'administrateur');
        ?>
        <p>Un paragraphe</p>
    </body>
</html>

 

On définit une valeur par défaut pour les arguments de notre fonction PHP

 

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>
        <title>Cours PHP & MySQL</title>
        <meta charset="utf-8">
        <link rel="stylesheet" href="cours.css">
    </head>
    
    <body>
        <h1>Titre principal</h1>
        <?php 
            function bonjour(...$prenoms){
                foreach($prenoms as $p){
                    echo 'Bonjour ' .$p. '<br>';
                }
            }
            
            bonjour('Mathilde', 'Pierre', 'Victor');
        ?>
        <p>Un paragraphe</p>
    </body>
</html>

 

On crée une fonction PHP avec un nombre d'arguments variable

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 :

TypeDéfinition
stringL’argument passé doit être de type string (chaine de caractères)
intL’argument passé doit être de type integer (nombre entier)
floatL’argument passé doit être de type float ou double (nombre décimal)
boolL’argument passé doit être de type boolean (booléen)
arrayL’argument passé doit être de type array (tableau)
iterableL’argument passé doit être de type array (tableau) ou une instance de l’interface Traversable
callableL’argument passé doit être de type callable (fonction de rappel)
Nom de classe / d’interfaceL’argument passé doit être une instance de la classe ou de l’interface donnée
selfL’argument passé doit être une instance de la même classe qui a défini la méthode
objectL’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>
        <title>Cours PHP & MySQL</title>
        <meta charset="utf-8">
        <link rel="stylesheet" href="cours.css">
    </head>
    
    <body>
        <h1>Titre principal</h1>
        <?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 ';
        ?>
        <p>Un paragraphe</p>
    </body>
</html>

 

Exemple du concept de typage des arguments dans notre fonction PHP

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>
        <title>Cours PHP & MySQL</title>
        <meta charset="utf-8">
        <link rel="stylesheet" href="cours.css">
    </head>
    
    <body>
        <h1>Titre principal</h1>
        <?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é
        ?>
        <p>Un paragraphe</p>
    </body>
</html>

 

On utilise le typage strict des arguments dans notre fonction PHP

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.

3 réflexions au sujet de “Contrôler le passage des arguments”

  1. Bonjour,
    Merci pour ces cours.
    Je me permet de signaler ceci :
    Dans la partie déclaration de fonction, lorsque celle-ci comporte des paramètre avec des arguments par défaut, mes essais montrent que :
    * Si je déclare le paramètre ayant une valeur par défaut avant ceux qui n’en ont pas => une erreur lors de l’exécution du script, que je passe ou non un argument au paramètre avec valeur par défaut.
    * Si je déclare le paramètre ayant une valeur par défaut APRES ceux qui n’en ont pas, => pas d’erreur, que je donne ou pas une valeur au paramètre qui en avait une par défaut.

    Or,
    Il me semble que c’est le contraire qui est indiqué dans la phrase :
    « 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 avant les autres dans la définition de la fonction. »

    Pliz help !!

    Merci encore

Laisser un commentaire