Les Fonctions en PHP 8

Une fonction est destinée à regrouper des instructions qui correspondent à un traitement. Ce traitement peut fournir un résultat. Ce résultat est retourné par la fonction. Dans un premier temps, on déclare la fonction, ensuite, on l'appelle 😎.

Ci-dessous, je fais un exemple. Pour déclarer ma fonction, je commence par utiliser le mot réservé function. Je le fais suivre du nom de la fonction. Dans mon exemple, ma fonction va calculer le produit de deux valeurs. Je vais lui donner le nom calculerProduit. Souvent, pour donner un nom à une fonction, on utilise un verbe suivi d'un nom. Le verbe pour dire ce que l'on fait, et le nom pour illustrer le verbe. Pour "l'orthographe" du nom de la fonction, aujourd'hui, on utilise le camelCase. C'est ce qui est utilisé dans les frameworks PHP, que ce soit Symfony ou Laravel.

Sur le plan pratique, il faut savoir que pour PHP, le nom de la fonction n'est pas case sensitive. Personnellement, je préfère respecter la casse. C'est ce que tout le monde fait. Je vous conseille de faire pareil.

Ensuite, je dois coder une liste de paramètres. Cette liste, je vais la mettre entre parenthèses. Ces paramètres, ce sont des variables qui recevront des valeurs, lorsque j'appellerai la fonction. Dans cet exemple, les paramètres vont être les deux variables $a et $b.

Maintenant, je vais passer au codage du corps de la fonction. Le corps de la fonction, je vais l'encapsuler dans une paire d'accolades.

Dans le corps de la fonction, je vais faire simplement un return du produit de $a par $b. Je fais le return pour retrourner une valeur.

Maintenant, je vais appeler la fonction en lui fournissant deux valeurs 2 et 3. Ces deux valeurs, ce sont les arguments qui sont passés à l'appel de la fonction.

<?php function calculerProduit($a,$b) { // corps de la fonction return $a * $b; } calculerProduit(2,3);

Le plus souvent, la fonction retourne un résultat, mais ce n'est pas obligatoire. Lorsque la fonction ne retourne pas de résultat, c'est en fait une procédure. Il n'y a pas d'autre moyen de faire une procédure en PHP.

Si j'appelle la fonction avec un seul argument, le parseur le détecte et me le dit. Si vous n'avez pas intelephense, alors vous le voyez à l'exécution. Vous avez une erreur fatale Parse Error qui est déclenchée par le PHP 😉.

Si vous mettez un argument de trop, il n'est pas utilisé. Vous le mettez pour rien, mais il n'y a pas d'erreur de détectée ni de déclenchée à l'exécution.

Pour faire cette partie, j'utilise une fonction qui va afficher trois couleurs.

<?php function afficherCouleurs($c1, $c2, $c3) { echo "c1 = $c1 | c2 = $c2 | c3 = $c3"; } // Affiche 'Bleu' | 'Blanc' | 'Rouge' afficherCouleurs('Bleu', 'Blanc', 'Rouge');

Maintenant, supposons que je veuille mettre une valeur par défaut à $c2. Eh bien, je n'ai pas le choix, il faut que je déplace $c2 à la fin de la liste des paramètres. Dans ce cas, à l'appel, $c2 sera facultatif.

<?php function afficherCouleurs($c1, $c3, $c2 = 'Blanc') { echo "c1 = $c1 | c2 = $c2 | c3 = $c3"; } // Affiche 'Bleu' | 'Blanc' | 'Rouge' afficherCouleurs('Bleu', 'Rouge');

Maintenant, supposons que je veuille deux valeurs par défaut. Une valeur par défaut pour $c2 et une valeur par défaut pour $c3. Je suis obligé de mettre les deux paramètres qui ont des valeurs par défaut à la fin. Si au moment de l'appel, j'utilise les deux valeurs par défaut, il n'y a pas de problème. Les deux arguments sont facultatifs.

<?php function afficherCouleurs($c1, $c2 = 'Blanc', $c3 = 'Rouge') { echo "c1 = $c1 | c2 = $c2 | c3 = $c3"; } // Affiche 'Bleu' | 'Blanc' | 'Rouge' afficherCouleurs('Bleu');

Si je veux utiliser la valeur par défaut de $c2 et mettre une valeur pour $c3 alors là la seule solution est d'utiliser les arguments nommés apparus dans la version 8.0 de PHP. Pour ça, je vais mettre le nom du paramètre devant l'argument.

Pour vous le prouver, ci-dessous, je fais un test en ne mettant pas l'argument nommé. A ce moment-là, la couleur Vert prend la place de $c2 pas celle de $c3 🙃.

<?php function afficherCouleurs($c1, $c2 = 'Blanc', $c3 = 'Rouge') { echo "c1 = $c1 | c2 = $c2 | c3 = $c3"; } // Affiche 'Bleu' | 'Vert' | 'Rouge' afficherCouleurs('Bleu', 'Vert');

Maintenant, ci-dessous, je nomme l'argument. A ce moment-là, la couleur Vert prend la place de $c3 😆.

<?php function afficherCouleurs($c1, $c2 = 'Blanc', $c3 = 'Rouge') { echo "c1 = $c1 | c2 = $c2 | c3 = $c3"; } // Affiche 'Bleu' | 'Blanc' | 'Vert' afficherCouleurs('Bleu', c3:'Vert');

Je peux mettre des valeurs par défaut partout ! Ensuite, je fais un appel en nommant les seuls arguments que je veux et dans l'ordre que je veux !

<?php function afficherCouleurs($c1 = 'Bleu', $c2 = 'Blanc', $c3 = 'Rouge') { echo "c1 = $c1 | c2 = $c2 | c3 = $c3"; } // Affiche 'Bleu' | 'Vert' | 'Jaune' afficherCouleurs(c3: 'Jaune', c2: 'Vert')

Je peux aussi mettre aucune valeur par défaut et nommer un argument. Par exemple, je nomme $c2. Là, je vois qu'à ce moment-là, il faut aussi nommer $c3. Les arguments nommés doivent être placés après les arguments positionnés. C'est la seule contrainte.

<?php function afficherCouleurs($c1, $c2, $c3) { echo "c1 = $c1 | c2 = $c2 | c3 = $c3"; } // Affiche 'Bleu' | 'Vert' | 'Jaune' afficherCouleurs('Bleu', c2: 'Vert', c3: 'Jaune');

En résumé : En PHP 8 au moment de l'appel d'une fonction, vous mettez d'abord les arguments positionnés et ensuite les arguments nommés. Vous pouvez mettre les arguments nommés dans n'importe quel ordre.

Je vais coder une fonction, que je vais appeler diviser. Cette fonction prend deux paramètres en entrée. Un premier paramètre $num qui est le numérateur et un deuxième paramètre $den qui est le dénominateur.

Vous avez la possibilité de mettre des contraintes de type sur les paramètres d'entrée d'une fonction et sur la valeur retournée 😃. Bien sûr, cela va avoir des conséquences si, à l'appel de la fonction, les arguments ne sont pas du type qui est attendu.

Je vais leur donner le type int et je vais mettre en sortie le type int. Pour ça je place int devant le nom des paramètres et : int avant les accolades.

<!DOCTYPE html> <html lang="fr"> <head> <meta charset="UTF-8"> </head> <body> <?php function diviser(int $num, int $den): int { return $num / $den; } var_dump(diviser(6, 2)); ?> </body> </html>

Je vais en profiter pour documenter ce morceau de code. Pour ça je vais me servir de VSCode et de l'extension PHPDoc Comment. Je clique sur function, j'ai une petite ampoule jaune qui apparaît, je clique sur l'ampoule et ensuite sur "Add PHPDoc for diviser". J'ai un pavé de documentation qui est inséré. Je le remplis. Ensuite, lorsque j'appelle la fonction, eh bien, j'ai la description qui apparaît. C'est très pratique.

Ci-dessous, je fais un premier appel avec pour arguments les entiers 6 et 2. Le résultat est un entier, tout est parfait.

<!DOCTYPE html> <html lang="fr"> <head> <meta charset="UTF-8"> </head> <body> <?php /** * @param int $num, numérateur de la division * @param int $den, dénominateur de la division * @return int résultat */ function diviser(int $num, int $den): int { return $num / $den; } var_dump(diviser(6, 2)); ?> </body> </html>

Maintenant, je vais changer la valeur d'un de mes arguments d'entrée. Je mets l'entier 7 comme numérateur. De cette manière, je vais provoquer un résultat flottant au niveau de la valeur retournée.

<?php /** * @param int $num, numérateur de la division * @param int $den, dénominateur de la division * @return int résultat */ function diviser(int $num, int $den): int { return $num / $den; } var_dump(diviser(7, 2)); // Provoque un résultat flottant. ?>

A l'exécution, j'ai une notification qui me prévient qu'une conversion implicite a provoqué une perte de précision.

Maintenant, je vais tester une valeur flottante sur une valeur d'entrée. Je vais mettre 6.5 pour le numérateur.

<?php var_dump(diviser(6.5, 2)); // Valeur flottante en entrée ?>

Si je mets des arguments qui ont des types qui peuvent être convertis, par exemple des chaînes numériques. Là, l'exécution se fait sans problème. Ce qui veut dire que, dans l'exemple précédent, c'était bien la perte de précision qui provoquait l'erreur et pas la conversion implicite.

<?php var_dump(diviser('6', '2')); // Chaînes numériques en entrée ?>

Si je mets des arguments qui ont des types qui ne peuvent pas être convertis, par exemple le tableau [6]. Là, si vous avez VSCode avec intelephense, eh bien, vous êtes prévenu. Si vous ne l'avez pas, alors à l'exécution, vous avez une erreur fatale TypeError.

<?php var_dump(diviser([6], 2)); // Un tableau sur une entrée ?>

<?php var_dump(diviser(6, 0)); // Erreur fatale Division par zéro ?>

Ce que je vais faire, c'est que je vais tester si le dénominateur vaut zéro, et dans ce cas, je vais retourner null. Je fais exprès de provoquer une erreur sur le type de la valeur retournée.

<?php function diviser(int $num, int $den): int { if ($den == 0) return null; return $num / $den; } var_dump(diviser(6, 0)); // Retourne null => TypeError ?>

Pour enlever cette erreur, il faut que je mette comme type de sortie, soit l'union de type null | int, soit un point d'interrogation devant le int : ?int. On dira que la valeur de sortie est nullable.

<!DOCTYPE html> <html lang="fr"> <head> <meta charset="UTF-8"> </head> <body> <?php /** * @param int $num, numérateur de la division * Si le numérateur vaut zéro la fonction retourne null * @param int $den, dénominateur de la division * @return int résultat */ function diviser(int $num, int $den): ?int { if ($den == 0) return null; return $num / $den; } var_dump(diviser(6, 0)); ?> </body> </html>

Toutes les exécutions que nous venons de faire, se sont faites, dans un mode par défaut, qui est le mode coercitif. Il existe un autre mode qui est le mode strict. Dans le mode strict, PHP refuse de faire toutes les conversions de type et déclenche un TypeError.

Pour cela, il faut ajouter une directive declare qui active le mode strict (* declare doit être la première instruction du script).

Si on veut demander à PHP, de vérifier, qu'il n'y aucune valeur de retournée, alors il faut mettre void comme étant le type de la valeur retournée. Si par erreur, vous retournez par exemple un booléen, et bien, vous aurez une erreur qui sera déjà détectée par le PHP de l'extension intelephense de VSCode 😉. Ce n'est pas nécessaire d'aller jusqu'à l'exécution pour que l'erreur soit signalée.