Les Fonctions
Présentation
Une fonction est une portion de code autonome qui effectue une tâche spécifique ou un ensemble de tâches connexes. Les fonctions sont utilisées pour organiser et réutiliser du code, améliorer la lisibilité et faciliter la maintenance et le débogage d'un programme.
Appeler une Fonction
Durant les chapitres précédents, nous avons utilisé quelques fonctions prédéfinies comme : readline(), random_int(), print_r(), etc. Lorsque nous appelons ces fonctions, nous suivons une structure commune : nous spécifions le nom de la fonction souhaitée, suivi de parenthèses.
Dans certains cas, les parenthèses peuvent être laissées vides, tandis que dans d'autres cas, il est nécessaire d'y fournir des valeurs, appelées "arguments". La nécessité d'utiliser des arguments dépend de la manière dont la fonction a été conçue, certains arguments étant facultatifs, tandis que d'autres sont obligatoires.
Structure et Déclaration de Fonctions
Avant d'explorer le processus de création d'une fonction personnalisée, il est important d'aborder leur nomenclature :
- Le nom d'une fonction commence généralement par un verbe qui décrit l'action.
- Il est recommandé d'utiliser le format camelCase (Le premier mot est en minuscule, et les mots suivants commencent par une majuscule).
- Il faut éviter les noms trop vagues ou génériques. Ils doivent indiquer clairement ce que fait la fonction, tout en restant aussi court que possible.
- Évitez de mélanger les langues : toutes les fonctions doivent être nommées dans une seule et même langue pour assurer la cohérence. Voici quelques exemples :
- ajouterUnFilm()
- effacerFichier()
- selectionnerTousLesUtilisateurs()
- ...
- Lorsqu'une fonction retourne un booléen (true ou false), elles doivent être nommées de manière à indiquer qu'elles renvoient une réponse affirmative ou négative. Voici quelques exemples :
- estValide()
- aDesErreurs()
- doitSeReconnecter()
- ...
Pour créer une fonction personnalisée, la déclaration classique se fait à l'aide du mot-clé function suivi du nom que l'on désire attribuer à la fonction :
// Déclaration d'une fonction :
function nomDeLaFonction()
{
// Bloc permettant de réaliser une série d'instructions.
}
// Appel de la fonction.
nomDeLaFonction();
Déclarons une fonction dont l'objectif sera d'afficher un petit "Hello World!" des familles :
<?php
// Déclaration d'une fonction nommée "direBonjourAuMonde()" permettant d'afficher "Hello World" :
function direBonjourAuMonde()
{
echo 'Hello World!';
}
// Appel de la fonction "direBonjourAuMonde()".
direBonjourAuMonde(); // Affiche : Hello World!
?>
Paramètres et Arguments
Avec ce type de déclaration, nous sommes limités. En effet, lorsqu'on utilise une fonction, il est souvent nécessaire de lui passer des informations à traiter (comme un nombre, une chaîne de caractères, un tableau, etc.). Pour ce faire, on utilise des paramètres dans la déclaration de la fonction et des arguments lors de son appel.
- Les paramètres : Les paramètres doivent être définis entre les parenthèses de la fonction lors de sa déclaration. Il s'agit en fait de variables qui vont récupérer les valeurs ou les références passées en argument lors de l'appel de la fonction.
- Les arguments : Les arguments doivent être passés entre les parenthèses de la fonction lorsqu'elle est appelée.
Lorsqu'une fonction est appelée, chaque argument passé est associé de manière linéaire au paramètre correspondant : le premier argument au premier paramètre, le deuxième argument au deuxième paramètre, et ainsi de suite.
// Déclaration d'une fonction avec autant de paramètres d'informations provenant de l'exterieur à lui transmettre :
function nomDeLaFonction($parametre1, $paramètre2, ...)
{
/*
Faire quelque chose avec les paramètres...
...
...
*/
}
// Appel de la fonction.
nomDeLaFonction(argument1, argument2, ...);
Voici un exemple concret de déclaration et d'appel d'une fonction personnalisée qui affiche le double de la valeur qui lui est passée en argument :
<?php
// Définition d'une fonction nommée "afficherLeDouble()" permettant d'afficher le double de la valeur reçue en paramètre "$b" :
function afficherLeDouble($b)
{
// Utilisation de l'opérateur de multiplication et d'affectation sur la variable "$b" pour multiplier sa valeur par 2.
$b *= 2;
// Afficher le double de la valeur de "$b".
echo "Valeur de \$b : $b" . PHP_EOL;
}
// Déclaration et initialisation de la variable "$a" avec un entier qui vaut 5.
$a = 5;
// Appel de la fonction "afficherLeDouble()" en transmettant la valeur de "$a" en tant qu'argument.
afficherLeDouble($a); // Affiche : Valeur de $b : 10
?>
Il est important de noter qu'en fonction de leur nature, les arguments peuvent être passés de deux manières différentes aux fonctions :
- Par valeur : Les types primitifs (entiers (int), flottants (float), chaînes de caractères (string), booléens (bool), NULL) et les tableaux (array) sont passés par valeur. Cela signifie que lorsqu'ils sont passés en argument à une fonction, une copie de leur valeur est transmise. Par conséquent, si la valeur est modifiée à l'intérieur de la fonction, la variable d'origine ne sera pas modifiée.
- Par référence : Les objets sont passés par référence. Cela signifie que lorsqu'ils sont passés en argument à une fonction, si des modifications sont apportées à l'objet au sein de la fonction, la variable d'origine sera elle aussi modifiée.
Dans l'exemple que nous venons de voir, la variable $a est un entier qui vaut 5. Lors de l'appel de la fonction, elle sera donc passée en argument par valeur (en tant que copie). Ce que signifie que la multiplication par deux réalisée dans la fonction n'aura aucune incidence sur la valeur de $a :
<?php
function afficherLeDouble($b)
{
// Utilisation de l'opérateur de multiplication et d'affectation
// sur la variable "$b" pour multiplier sa valeur par 2.
$b *= 2;
// Afficher le double de la valeur de "$b".
echo "Valeur de \$b : $b" . PHP_EOL;
}
// Déclaration et initialisation de la variable "$a" avec un entier qui vaut 5.
$a = 5;
// Appel de la fonction "afficherLeDouble()" en passant la variable "$a" comme argument par valeur (une copie).
afficherLeDouble($a); // Affiche : Valeur de $b : 10
// Bien que "$a" ait été utilisé comme argument dans la fonction "afficherLeDouble()" et que la valeur de l'argument ait été doublée à l'intérieur de la fonction, la valeur initiale de "$a" reste inchangée.
echo "Valeur de \$a : $a"; // Affiche : Valeur de $a : 5
?>
Cependant, pour les objets, la fonction reçoit une référence à l'objet, ce qui signifie que les modifications apportées à l'objet à l'intérieur de la fonction seront reflétées à l'extérieur de la fonction :
<?php
function afficherLeDoubleProprieteValeur($b)
{
$b->valeur *= 2;
echo 'Valeur de "\$b->valeur" : ' . $b->valeur . PHP_EOL;
}
// Déclaration et initialisation d'une variable "$a" avec une instance d'un objet standard vide.
$a = new stdClass();
// Ajout d'une propriété nommée "valeur" à l'objet "$a", initialisée avec l'entier 5.
$a->valeur = 5;
// Appel de la fonction "afficherLeDoubleProprieteValeur()" en lui passant l'objet "$a" comme argument par référence.
afficherLeDoubleProprieteValeur($a); // Affiche : Valeur de "$b->valeur" :
// La valeur de la propriété "$a->valeur" a bien été modifiée, car la fonction opère sur une référence de l'objet.
echo 'Valeur de "\$a->valeur" : ' . $a->valeur; // Affiche : Valeur de "$a->valeur" : 10
?>
Si vous désirez forcer le passage d'un argument en référence plutôt qu'en copie, vous devez préfixer le nom du paramètre avec le symbole & :
<?php
// La fonction "afficherLeDouble()" accepte un argument par référence. On signifie le passage par référence à l'aide du symbole &.
function afficherLeDouble(&$b)
{
$b *= 2;
echo "Valeur de \$b : $b" . PHP_EOL;
}
$a = 5;
afficherLeDouble($a); // Affiche : Valeur de $b : 10
// Étant donné que $a est passé par référence à la fonction "afficherLeDouble()",
// la valeur de $a a été doublée à l'intérieur de la fonction et sera également modifiée à l'extérieur de la fonction.
echo "Valeur de \$a : $a"; // Affiche : Valeur de $a : 10
?>
Il est important d'utiliser cette technique avec prudence car elle peut entraîner des comportements inattendus et rendre le code plus difficile à comprendre et à maintenir. Il est souvent préférable de privilégier le passage par valeur lorsque cela est possible.
Il est possible d'assigner une valeur par défaut à un paramètre lorsqu'il est facultatif. Ainsi, si l'utilisateur ne fournit pas d'argument pour ce paramètre, la valeur par défaut sera utilisée automatiquement :
<?php
// Si l'utilisateur ne passe pas d'argument au paramètre facultatif "$prenom",
// la valeur par défaut 'inconnu(e)' lui sera automatiquement attribuée.
function direBonjour($prenom = 'inconnu(e)')
{
echo "Bonjour cher(e) $prenom!";
}
// Appel de la fonction "afficherLeDouble()" en transmettant la valeur de "$a" en tant qu'argument.
direBonjour(); // Affiche : Bonjour cher(e) inconnu(e)!
?>
Jusqu'à présent, nous avons travaillé avec des fonctions ayant un seul paramètre. Cependant, il est tout à fait possible d'utiliser des fonctions avec plusieurs paramètres. Pour illustrer cela, supposons que nous souhaitons créer une fonction qui calcule et affiche le périmètre d'un rectangle :
<?php
// Calcule et affiche le périmètre d'un rectangle.
function afficherPerimetreRectangle($longueur, $largeur)
{
// Utilisation de la formule pour calculer le périmètre.
$perimetre = 2 * ($longueur + $largeur);
// Affiche le résultat.
echo "Le périmètre du rectangle est : $perimetre";
}
// Déclaration et initialisation des variables qui seront passées en argument à la fonction "afficherPerimetreRectangle()" :
$longueurRectangle = 5;
$largeurRectangle = 3;
// Appel de la fonction pour afficher le périmètre du rectangle.
afficherPerimetreRectangle($longueurRectangle, $largeurRectangle); // Affiche : Le périmètre du rectangle est : 16
?>
Il est tout à fait possible d'utiliser une fonction sans connaître à l'avance le nombre d'arguments qu'elle recevra. Cette flexibilité est permise grâce à l'opérateur de déversement ..., qui permet de traiter un nombre variable d'arguments.
Pour illustrer cette idée, imaginons que nous souhaitons créer une fonction qui calcule la somme de plusieurs nombres, sans utiliser un tableau comme argument, tout en permettant que le nombre de valeurs à calculer puisse varier d'un appel à l'autre :
<?php
// Calcule et affiche la somme de plusieurs valeurs (le nombre d'arguments est indéfini).
function afficherSomme(...$valeurs)
{
// Initialisation de $somme.
$somme = 0;
// Parcourir les arguments.
foreach ($valeurs as $valeur)
{
$somme += $valeur;
}
// Afficher la somme.
echo "Somme : $somme" . PHP_EOL;
}
// Appels de la fonction avec différents quantités de nombres :
afficherSomme(15, 5, 30); // Affiche : Somme 1 : 50
afficherSomme(10, 20); // Affiche : Somme 1 : 42
?>
Grâce à l'utilisation de l'opérateur de déversement, cette fonction peut accepter un nombre variable d'arguments, et tous ces arguments sont rassemblés dans un tableau appelé $valeurs à l'intérieur de la fonction.
En revanche, si vous appelez une fonction en préfixant un tableau passé en argument avec l'opérateur de décomposition $valeurs, la fonction ne recevra pas un tableau, mais plutôt autant d'arguments qu'il y avait d'éléments dans le tableau.
<?php
// Calcule et affiche la somme de plusieurs valeurs (le nombre d'arguments est indéfini).
function afficherSomme($valeur1, $valeur2)
{
// Calculer la somme des deux valeurs passées en argument.
$somme = $valeur1 + $valeur2;
// Afficher la somme.
echo "Somme : $somme" . PHP_EOL;
}
// Déclarer la variable "$valeurs" avec un tableau comprenant les deux nombres que l'on désire additionner.
$valeurs = [2, 5];
// Appel de la fonction en prefixant un tableau "$valeurs" passé en argument avec l'opérateur de décomposition.
afficherSomme(...$valeurs); // Affiche : Somme : 7
?>
S'il y avait plus d'éléments dans le tableau que d'arguments attendus, les éléments supplémentaires seraient ignorés. En revanche, si le tableau contenait moins d'éléments que le nombre d'arguments attendus, PHP générerait une erreur.
Portée des Variables dans les Fonctions
Pour exploiter une variable déclarée en dehors d'une fonction au sein de celle-ci, on pourrait être tenté de la déclarer préalablement, comme illustré dans l'exemple suivant avec la variable $a :
<?php
// Déclaration et initialisation de la variable "$a" avec un entier qui vaut 5.
$a = 5;
function afficherLeDouble()
{
// Déclaration et initialisation de la variable "$b"
// avec le double de la valeur de "$a".
$b = $a * 2;
// Afficher le double de la valeur de "$a".
echo "Valeur de \$b : $b" . PHP_EOL;
}
// Appel de la fonction "afficherLeDouble()".
afficherLeDouble(); // Affiche : Warning: Undefined variable $a in...
?>
Cependant, en PHP, les fonctions sont définies avec une portée locale, ce qui signifie que les variables définies en dehors d'une fonction appartiennent à la portée globale et ne sont pas directement accessibles dans la fonction. Bien que l'accès aux variables globales soit possible, notamment à l'aide du mot-clé global, il est préférable de limiter leur utilisation pour préserver la modularité et éviter les effets secondaires indésirables
<?php
// Déclaration et initialisation de la variable "$a" avec un entier qui vaut 5.
$a = 5;
function afficherLeDouble()
{
// Rendre la variable globale "$a" accessible.
global $a;
// Déclaration et initialisation de la variable "$b"
// avec le double de la valeur de "$a".
$b = $a * 2;
// Afficher le double de la valeur de "$a".
echo "Valeur de \$b : $b" . PHP_EOL;
}
// Appel de la fonction "afficherLeDouble()".
afficherLeDouble(); // Affiche : Valeur de $b : 10
?>
Comme nous venons de le voir, les fonctions en PHP ont une portée locale. Cela signifie que les variables déclarées à l'intérieur d'une fonction ne sont accessibles qu'au sein de cette dernière.
Dans l'exemple suivant, nous déclarons une fonction qui calcule le double d'une valeur mais qui ne l'affiche plus elle même. On aimerait pouvoir utiliser le résultat en dehors de la fonction pour lui faire subir toutes sortes de manipulations :
<?php
function calculerLeDouble($valeur)
{
// Initialiser la valeur de "$resultat" avec le double de la valeur "$valeur".
$resultat = $valeur * 2;
}
// Appel de la fonction "calculerLeDouble()" avec l'entier 5 en argument.
calculerLeDouble(5);
// On tente d'afficher la valeur de la variable $resultat. Cependant, cette tentative renverra une erreur
// car la portée de la variable est limitée au bloc dans lequel elle a été déclarée dans ce cas-ci "calculerLeDouble()".
echo $resultat; // Affiche : HP Warning: Undefined variable $resultat in...
?>
La variable $resultat est déclarée localement à l'intérieur du bloc d'instructions de la fonction calculerLeDouble(). Cela signifie qu'elle n'existe que dans le contexte de cette fonction. Si vous essayez d'accéder à cette variable en dehors de la fonction ou en dehors du bloc de code où elle est déclarée, vous obtiendrez une erreur PHP indiquant que la variable est indéfinie.
La portée des variables détermine où une variable est accessible et utilisable dans votre code. En d'autres termes, elle définit la zone ou le contexte dans lequel une variable existe. Dans notre exemple, la variable $resultat existe uniquement à l'intérieur de la fonction calculerLeDouble(). Une fois que vous sortez de cette fonction, la variable cesse d'exister et ne peut plus être utilisée.
Si vous souhaitez utiliser la valeur d'une variable à l'extérieur d'une fonction, vous devez utiliser l'instruction return suivie de la valeur que vous souhaitez renvoyer en dehors du bloc de la fonction. Notez que lorsqu'un return est exécuté, la fonction s'arrête et toutes les instructions qui suivent ne seront donc pas exécutées.
<?php
function calculerLeDouble($valeur)
{
// La fonction retourne le double de la valeur "$valeur".
return ($valeur * 2);
}
// Appel de la fonction "calculerLeDouble()" avec l'entier 5 en argument.
// La variable "$resultat" va récupérer la valeur située à droite de
// l'instruction "return" présente dans la fonction "calculerLeDouble()".
$resultat = calculerLeDouble(5);
// Afficher la valeur qui a été retournée par la fonction "calculerLeDouble()" et placée dans la variable $resultat.
echo $resultat; // Affiche : 10
?>
En PHP, pour retourner plusieurs valeurs d'une fonction, les structures les plus couramment utilisées sont les tableaux (classiques ou associatifs) :
<?php
function recupererPersonnages()
{
$lePhotographe = 'Claudy';
$laCommissaire = 'Laurence';
// Retourner plusieurs valeurs.
return [$lePhotographe, $laCommissaire];
}
// Déclaration et initialisation de la variable "$personnages" avec
// le résultat retourné par la fonction "recupererPersonnages()".
$personnages = recupererPersonnages();
// Afficher les personnages :
print_r($personnages);
/*
Affiche :
Array
(
[0] => Claudy
[1] => Laurence
)
*/
?>
Si vous souhaitez travailler directement avec des variables plutôt qu'avec un tableau, vous pouvez utiliser la déstructuration. La déstructuration de tableau permet d'extraire les éléments d'un tableau et de les assigner à des variables de manière concise, en utilisant la syntaxe des crochets []. Cela simplifie l'accès aux éléments individuels et facilite leur manipulation :
<?php
function recupererPersonnages()
{
$lePhotographe = 'Claudy';
$laCommissaire = 'Laurence';
// Retourner plusieurs valeurs.
return [$lePhotographe, $laCommissaire];
}
// Déstructuration du tableau retourné par la fonction "recupererPersonnages()"
// sous forme de variables individuelles "$photographe" et "$commissaire".
[$photographe, $commissaire] = recupererPersonnages();
// Afficher les personnages :
echo $photographe; // Affiche : Claudy
echo $commissaire; // Affiche : Laurence
?>
Il est également possible d'utiliser la déstructuration avec les tableaux associatifs. Dans ce cas, vous devez spécifier les clés textuelles que vous souhaitez extraire et les associer aux variables de votre choix à l'aide de la syntaxe cleTextuelle => nomDeVariable.
<?php
function recupererPersonnages()
{
$lePhotographe = 'Claudy';
$laCommissaire = 'Laurence';
// Retourner plusieurs valeurs à l'aide d'un objet.
return [
'lePhotographe' => $lePhotographe,
'laCommissaire' => $laCommissaire
];
}
// Déstructuration du tableau retourné par la fonction "recupererPersonnages()"
// sous forme de variables individuelles "$photographe" et "$commissaire".
['lePhotographe' => $photographe, 'laCommissaire' => $commissaire] = recupererPersonnages();
// Afficher les personnages :
echo ($photographe); // Affiche : Claudy
echo ($commissaire); // Affiche : Laurence
?>
Déclaration Typée de Fonctions
Allons voir ce que dit la documentation officielle de PHP concernant la fonction readline() : https://www.php.net/manual/fr/function.readline.php
Voici la structure de la fonction telle qu'elle est décrite dans la documentation de PHP :
readline(?string $prompt = null): string|falseDétaillons les segments de cette syntaxe :
- readline : Le nom de la fonction.
-
(?string $prompt = null) : Il s'agit de la déclaration des paramètres de la fonction.
- ?string : Cela signifie que la fonction attend un paramètre de type chaîne de caractères. Le ? avant string indique que ce paramètre peut également accepter la valeur null. Notez qu'il s'agit d'une manière plus concise d'écrire null|string.
- $prompt : C'est le nom du paramètre. Lorsque vous appelez la fonction, vous pouvez fournir une valeur qui sera attribuée à ce paramètre.
- = null : Cela signifie que si vous n'appelez pas la fonction avec un argument pour ce paramètre, il prendra automatiquement la valeur par défaut de null.
- $prompt = null : Si aucun argument n'est précisé lors de l'appel de la fonction, celle-ci attribuera une valeur par défaut, dans ce cas, la valeur null.
-
: string|false : C'est la déclaration du type de retour de la fonction. Cela signifie que la fonction peut renvoyer deux types de valeurs possibles :
- string : Une chaîne de caractères si la fonction réussit à lire une ligne depuis l'entrée.
-
false : renvoyé lorsqu'on atteint la fin de l'entrée (EOF = End Of File).
Cela peut arriver dans deux cas :
- l'utilisateur signale la fin de saisie dans le terminal via un raccourci clavier spécial ;
- l'entrée provient d'un fichier et le curseur de lecture est arrivé au bout.
La déclaration typée de fonctions permet de spécifier les types attendus pour les paramètres d'une fonction, ainsi que le type de valeur renvoyée par la fonction. Cela offre plusieurs avantages, notamment une meilleure documentation du code, une réduction des erreurs de type, et une compréhension plus claire des interactions entre les fonctions :
<?php
// Cette fonction attend un argument de type "float" et n'a pas de valeur de retour ": void".
function afficherLeDouble(float $valeur): void
{
// Afficher le double de la valeur passée en argument.
echo ($valeur * 2);
}
// Appel de la fonction "afficherLeDouble()" avec la chaîne de caractère "5" en argument.
afficherLeDouble('5'); // Affiche : 10
?>
Vous avez peut-être remarqué que j'ai utilisé une chaîne de caractères '5' comme argument, alors que le paramètre de la fonction était configuré pour accepter uniquement un type "float". De manière surprenante, PHP a accepté cette chaîne de caractères sans générer d'erreur. Cette tolérance de PHP s'explique par le fait que la chaîne de caractères '5' est uniquement composée de valeurs numériques, et PHP effectue automatiquement une conversion implicite pour la traiter comme un nombre flottant 5.0, ce qui a permis l'exécution de l'opération.
Pour contrer cette flexibilité et encourager une programmation plus rigoureuse, il existe une instruction appelée declare(strict_types=1); que vous devez déclarer au début de chaque page où vous souhaitez que cette vérification stricte des types soit prise en compte. Cette pratique incite les développeurs à travailler de manière plus précise et à éviter les conversions implicites ou inattendues entre les types. Cela renforce la robustesse de votre code en détectant les erreurs de typage dès leur apparition.
Cependant, il est important de noter que même avec declare(strict_types=1), PHP continuera de convertir implicitement les valeurs "integer" en "float" si nécessaire pour les opérations arithmétiques, car cela ne constitue généralement pas une incohérence de type majeure dans les calculs numériques :
<?php
// Appliquer la déclaration stricte des types.
declare(strict_types=1);
// Cette fonction attend un argument de type "float" et n'a pas de valeur de retour ": void".
function afficherLeDouble(float $valeur): void
{
// Afficher le double de la valeur passée en argument.
echo ($valeur * 2);
}
// Appel de la fonction "afficherLeDouble()" avec la chaîne de caractère "5" en argument.
afficherLeDouble('5'); // Affiche : Fatal error: Uncaught TypeError: afficherLeDouble(): Argument #1 ($valeur) must be of type float, string given, called in...
?>
Exercices - Part 01
Exo-fonctions-01
Objectif : Créer une fonction permettant de calculer la moyenne des nombres contenus dans un tableau et d'afficher un résultat détaillé sous forme de chaîne de caractères.
Instructions :
- Copiez le code à compléter dans votre éditeur de code :
<?php // Appliquer la déclaration stricte des types. declare(strict_types=1); /* À COMPLÉTER : Déclaration de la fonction... ... ... */ // Le tableau dont en veut calculer la moyenne. $listeDeNombres = [8, 7, 6.5, 4.5, 7, 8]; // Appeler la fonction "afficherMoyenne()" pour afficher la liste des nombres du tableau listeDeNombres, ainsi que leur moyenne. afficherMoyenne($listeDeNombres); // Affiche : La moyenne des nombres [ 8, 7, 6.5, 4.5, 7, 8 ] : 6.8333333333333 ?> - Déclarez votre fonction afficherMoyenne() avec le paramètre suivant :
- $nombres : Le tableau des nombres dont il faut calculer la moyenne.
- Calculer la moyenne des nombres du tableau passé en argument. Attention aux erreurs pouvant être générées par un tableau vide (division par zéro)
- Convertir le tableau en chaîne de caractères.
- Afficher la chaîne de caractères (liste des nombres) suivie du résultat de la moyenne.
Vous aurez besoin des fonctions prédéfinies suivantes :
- implode() : Permet de convertir un tableau en chaîne de caractères.
- array_sum() : Permet de calculer la somme des éléments d'un tableau.
- Pour obtenir plus d'informations concernant cette méthode, rendez-vous sur la documentation officielle de PHP.
Exo-fonctions-02
Objectif : Réorganiser le code réalisé lors de l'exercice précédent en décomposant la logique en 2 petites fonctions. Cela permettra à chaque fonction de se concentrer sur une tâche spécifique, rendant le code plus clair, plus facile à maintenir et plus évolutif.
Instructions :
- Copiez le code à compléter dans votre éditeur de code :
<?php // Appliquer la déclaration stricte des types. declare(strict_types=1); /* À COMPLÉTER : Déclaration des deux fonctions... ... ... */ // Le tableau dont en veut calculer la moyenne. $listeDeNombres = [8, 7, 6.5, 4.5, 7, 8]; // Appeler la fonction "calculerMoyenne()" pour calculer les nombres présents dans le tableau "$listeDeNombres". $moyenne = calculerMoyenne($listeDeNombres); // Convertir le tableau en chaîne de caractères. $listeDeNombres = convertirTableauEnChaineDeCaracteres($listeDeNombres); // Afficher la moyenne. echo "La moyenne des nombres [ $listeDeNombres ] : $moyenne"; // Affiche : La moyenne des nombres [ 8, 7, 6.5, 4.5, 7, 8 ] : 6.8333333333333 ?> - Déclarez votre fonction calculerMoyenne() avec le paramètre suivant :
- $nombres : Un tableau avec les nombres dont il faut calculer la moyenne.
- Retourner la moyenne des nombres contenus dans le tableau passé en argument, tout en évitant les erreurs en cas de tableau vide (division par zéro).
- Déclarez votre fonction convertirTableauEnChaineDeCaracteres() avec le paramètre suivant :
- nombres() : Le tableau que l'on souhaite convertir en chaîne de caractères.
- Retourner la conversion en chaîne de caractères du tableau passé en argument avec une virgule et un espace séparant chaque éléments , .
Exo-fonctions-03
Objectif : Développer une série de fonctions permettant d'afficher la moyenne des nombres contenus dans un tableau, en ne prenant en compte que les valeurs valides (c'est-à-dire les valeurs numériques). Ces fonctions afficheront également le résultat de la somme, en précisant les valeurs utilisées pour le calcul ainsi que celles ayant été rejetées.
Instructions :
- Copiez le code à compléter dans votre éditeur de code :
<?php // Appliquer la déclaration stricte des types. declare(strict_types=1); /* À COMPLÉTER : Déclaration des 4 fonctions... ... ... */ // Le tableau dont en veut calculer la moyenne. $listeDeNombres = [8, 'trois', 7, 6.5, 'cinq', 4.5, 7, 8]; // Appeler la fonction "afficherMoyenne()" pour calculer et afficher les nombres présents dans le tableau "$listeDeNombres". afficherMoyenne($listeDeNombres); /* Affiche : La moyenne des nombres [ 8, 7, 6.5, 4.5, 7, 8 ] : 6.8333333333333 Les valeurs ayant été rejetées ['trois', 'cinq'] */ ?> - Déclarez votre fonction calculerSomme() ( array_sum() maison ) avec le paramètre suivant :
- $nombres : Un tableau avec les nombres dont il faut calculer la somme.
- Parcourir les valeurs du tableau passé en argument $nombres, additionner chaque valeur numérique au résultat de la somme et ajouter les valeurs valides dans un tableau de sortie.
- Retourner un tableau avec la somme et le tableau avec les nombres valides.
- Déclarez votre fonction calculerMoyenne() avec le paramètre suivant :
- $nombres : Un tableau avec les nombres dont il faut calculer la moyenne.
- Récupérer la somme et les tableaux des nombres valides à l'aide de la fonction calculerSomme().
- Calculer la moyenne.
- Retourner un tableau avec la moyenne et le tableau avec les nombres valides.
- Déclarez votre fonction convertirTableauEnChaineDeCaracteres() avec le paramètre suivant :
- $nombres : Le tableau que l'on souhaite convertir en chaîne de caractères.
- Retourner la conversion en chaîne de caractères du tableau passé en argument avec une virgule et un espace séparant chaque éléments , .
- Déclarez votre fonction afficherMoyenne() avec le paramètre suivant :
- $nombres : Le tableau que l'on souhaite convertir en chaîne de caractères.
- Récupérer la moyenne et les tableaux des nombres valides à l'aide de la fonction calculerMoyenne().
- Créer un tableau avec les nombres invalides (non-numériques) à l'aide de la fonction prédéfinie array_diff(), du tableau d'origine $nombres et du tableau ne contenant que les nombres valides.
- Utiliser la fonction convertirTableauEnChaineDeCaracteres() pour convertir le tableau des nombres invalides ainsi celui des nombres valides en chaînes de caractères.
- Afficher les deux tableaux convertis ainsi que la moyenne.
Vous aurez besoin de la fonction prédéfinie suivante :
- array_diff() : Permet de comparer plusieurs tableaux et de retourner un tableau contenant les éléments présents dans le premier tableau mais absents des autres tableaux comparés..
- Pour obtenir plus d'informations concernant cette méthode, rendez-vous sur la documentation officielle de PHP.
Exo-fonctions-04
Objectif : Créer un programme qui permet de convertir un prix hors taxes ( HT ) en prix toutes taxes comprises ( TTC ) en utilisant 2 fonctions distinctes.
Instructions :
- Copiez le code à compléter dans votre éditeur de code :
<?php // Appliquer la déclaration stricte des types. declare(strict_types=1); /* À COMPLÉTER : Déclaration des 2 fonctions... ... ... */ // Afficher le prix TTC d'un article de 100 euros HT, la TVA est de 21%. echo ajouterTva(100, 21) . PHP_EOL; // Affiche : 121 // Afficher le prix TTC d'un article de 100 euros HT, la TVA est de 12%. echo ajouterTva(100, 12) . PHP_EOL; // Affiche : 112 ?> - Déclarez votre fonction calculerMontantTvaPrixHT() avec les paramètres suivants :
- $prixHt : Le prix hors TVA.
- $tva : Le taux de TVA.
- Calculer et retourner le montant de la TVA à partir d'un prix hors TVA :
prix hors TVA * (taux de la TVA / 100).
- Déclarez votre fonction ajouterTva() avec les paramètres suivants :
- $prixHt : Le prix hors TVA.
- $tva : Le taux de TVA.
- Obtenir le montant de la TVA à l'aide de la fonction calculerMontantTvaPrixHT().
- Ajouter le montant de la TVA au prix hors TVA.
- Arrondir le montant à 3 décimales.
- Retourner le montant arrondi.
Exo-fonctions-05
Objectif : Créer un programme qui permet de convertir un prix toutes taxes comprises ( TTC ) en prix hors taxes ( HT ) en utilisant 2 fonctions distinctes.
Instructions :
- Copiez le code à compléter dans votre éditeur de code :
<?php // Appliquer la déclaration stricte des types. declare(strict_types=1); /* À COMPLÉTER : Déclaration des 2 fonctions... ... ... */ // Afficher le prix HT d'un article de 100 euros TTC, la TVA est de 21%. echo retirerTva(100, 21) . PHP_EOL; // Affiche : 82.645 // Afficher le prix HT d'un article de 100 euros TTC, la TVA est de 12%. echo retirerTva(100, 12) . PHP_EOL; // Affiche : 89.286 ?> - Déclarez votre fonction calculerMontantTvaPrixTTC() avec les paramètres suivants :
- $prixTtc : Le prix avec TVA.
- $tva : Le taux de TVA.
- Calculer et retourner le montant de la TVA à partir d'un avec TVA :
(prix avec TVA * taux de la TVA) / (100 + taux de la TVA).
- Déclarez votre fonction retirerTva() avec les paramètres suivants :
- $prixTtc : Le prix avec TVA.
- $tva : Le taux de TVA.
- Obtenir le montant de la TVA à l'aide de la fonction calculerMontantTvaPrixTTC().
- Retirer le montant de la TVA au prix hors TVA.
- Arrondir le montant à 3 décimales.
- Retourner le montant arrondi.
Exo-fonctions-06
Objectif : Créer une fonction permettant de vérifier la validité d'une adresse email.
Instructions :
- Copiez le code à compléter dans votre éditeur de code :
<?php // Appliquer la déclaration stricte des types. declare(strict_types=1); /* À COMPLÉTER : Déclaration la fonction... ... ... */ // Appeler la fonction "estValideEmail()" pour vérifier si l'adresse email "claudy.focan@gmail.com" est valide. $estEmailRempli = estValideEmail("claudy.focan@gmail.com"); var_dump($estEmailRempli); // Affiche : bool(true) // Appeler la fonction "estValideEmail()" pour vérifier si l'adresse email "claudy.focan" est valide. $estEmailRempli = estValideEmail("claudy.focan"); var_dump($estEmailRempli); // Affiche : bool(false) ?> - Déclarez votre fonction estValideEmail() avec le paramètre suivant :
- $email : L'email dont on veut vérifier la validité.
- Vérifier la validité de l'email entré en argument.
- Retourner true si l'email est valide, sinon retourner false.
Vous aurez besoin de la fonction prédéfinie suivante :
- filter_var() : Pour vérifier la validité d'une adresse email.
- Pour obtenir plus d'informations concernant ces fonctions prédéfinies, rendez-vous sur la documentation officielle de PHP.
Exo-fonctions-07
Objectif : Créer une fonction permettant de vérifier qu'une chaîne de caractères respecte une longueur minimale.
Instructions :
- Copiez le code à compléter dans votre éditeur de code :
<?php // Appliquer la déclaration stricte des types. declare(strict_types=1); /* À COMPLÉTER : Déclaration la fonction... ... ... */ // Appeler la fonction "respecteLongueurMinimale()" pour vérifier si la chaîne "saperlipopette" possède au moins 2 caractères. $estLongueurValide = respecteLongueurMinimale("saperlipopette", 2); var_dump($estLongueurValide ); // Affiche : bool(true) // Appeler la fonction "respecteLongueurMinimale()" pour vérifier si la chaîne "saperlipopette" possède au moins 30 caractères. $estLongueurValide = respecteLongueurMinimale("saperlipopette", 30); var_dump($estLongueurValide ); // Affiche : bool(false) ?> - Déclarez votre fonction respecteLongueurMinimale() avec les paramètres suivants :
- $entreeUtilisateur : La chaîne de caractères dont il faut vérifier la longueur minimale.
- $longueurMin : La valeur minimale que doit posséder la chaîne de caractères.
- Vérifier si la longueur de la chaîne est au moins aussi grande que la longueur minimale spécifiée.
- Retourner true si la longueur minimale est respectée, sinon retourner false.
Vous aurez besoin de la fonction prédéfinie suivante :
- mb_strlen() : Pour vérifier le nombre de caractère d'une chaîne.
- Pour obtenir plus d'informations concernant ces fonctions prédéfinies, rendez-vous sur la documentation officielle de PHP.
Exo-fonctions-08
Objectif : Créer une fonction permettant de vérifier qu'une chaîne de caractères ne dépasse pas une longueur maximale.
Instructions :
- Copiez le code à compléter dans votre éditeur de code :
<?php // Appliquer la déclaration stricte des types. declare(strict_types=1); /* À COMPLÉTER : Déclaration la fonction... ... ... */ // Appeler la fonction "respecteLongueurMaximale()" pour vérifier si la chaîne "saperlipopette" ne dépasse pas la limites de 30 caractères. $estLongueurValide = respecteLongueurMaximale("saperlipopette", 30); var_dump($estLongueurValide ); // Affiche : bool(true) // Appeler la fonction "respecteLongueurMaximale()" pour vérifier si la chaîne "saperlipopette" ne dépasse pas les limites de 2 caractères. $estLongueurValide = respecteLongueurMaximale("saperlipopette", 2); var_dump($estLongueurValide ); // Affiche : bool(false) ?> - Déclarez votre fonction respecteLongueurMaximale() avec les paramètres suivants :
- $entreeUtilisateur : La chaîne de caractères dont il faut vérifier si elle ne dépasse pas la longueur maximale.
- $longueurMax : La valeur maximale que peut posséder la chaîne de caractères.
- Vérifier si la longueur de la chaîne ne dépasse pas la longueur maximale spécifiée.
- Retourner true si la longueur maximale est respectée, sinon retourner false.
Vous aurez besoin de la fonction prédéfinie suivante :
- mb_strlen() : Pour vérifier le nombre de caractère d'une chaîne.
- Pour obtenir plus d'informations concernant ces fonctions prédéfinies, rendez-vous sur la documentation officielle de PHP.
Exo-fonctions-09
Objectif : Créer une fonction permettant de vérifier que le nombre de caractères d'une chaîne est compris entre une valeur minimale et une valeur maximale.
Instructions :
- Copiez le code à compléter dans votre éditeur de code :
<?php // Appliquer la déclaration stricte des types. declare(strict_types=1); /* À COMPLÉTER : Déclaration la fonction... ... ... */ // Appeler la fonction "respecteLongueurMinEtMax()" pour vérifier si le nombre de caractères de la chaîne "saperlipopette" est comprise entre 2 et 30 caractères. $estLongueurValide = respecteLongueurMinEtMax("saperlipopette", 2, 30); var_dump($estLongueurValide); // Affiche : bool(true) // Appeler la fonction "respecteLongueurMinEtMax()" pour vérifier si le nombre de caractères de la chaîne "saperlipopette" est comprise entre 2 et 8 caractères. $estLongueurValide = respecteLongueurMinEtMax("saperlipopette", 2, 8); var_dump($estLongueurValide); // Affiche : bool(false) ?> - Copiez les deux fonctions créées précédement respecteLongueurMinimale() et respecteLongueurMaximale().
- Déclarez votre fonction respecteLongueurMinEtMax() avec les paramètres suivants :
- $entreeUtilisateur : La chaîne de caractères dont il faut vérifier si elle est comprise entre la valeur minimale et la valeur maximale.
- $longueurMin : La valeur minimale que doit posséder la chaîne de caractères.
- $longueurMax : La valeur maximale que peut posséder la chaîne de caractères.
- Vérifier si la longueur de la chaîne est comprise entre la valeur minimale et la valeur maximale en utilisant les fonctions respecteLongueurMinimale() et respecteLongueurMaximale().
- Retourner true si les longueur minimale et maximale sont respectées, sinon retourner false.
Exo-fonctions-10
Objectif : Créer une fonction permettant de vérifier si un champ spécifique d'un formulaire a bien été rempli.
Instructions :
- Copiez le code à compléter dans votre éditeur de code :
<?php // Appliquer la déclaration stricte des types. declare(strict_types=1); /* À COMPLÉTER : Déclaration la fonction... ... ... */ // Simulation d'entrées utilisateur provenant d'un formulaire. $entreesUtilisateur = [ 'nom' => 'Claudy', 'email' => 'claudy.focan@gmail.com' ]; // Appeler la fonction "estRempli()" pour vérifier que le champ requis nommé "nom" a bien été rempli. $estNomRempli = estRempli("nom", $entreesUtilisateur); var_dump($estNomRempli); // Affiche : bool(true) // Appeler la fonction "estRempli()" pour vérifier que le champ requis nommé "prenom" a bien été rempli. $estPrenomRempli = estRempli("prenom", $entreesUtilisateur); var_dump($estPrenomRempli); // Affiche : bool(false) ?> - Déclarez votre fonction estRempli() avec les deux paramètres suivants :
- $nomDuChampnom : Nom de la clé textuelle dont on veut vérifier la valeur.
- $entreesUtilisateur : Le tableau des entrées utilisateur dans lequel on va chercher la valeur de la clé textuelle passée en premier argument.
- Vérifier que la clé textuelle passée en premier argument est présente dans le tableau passé en second argument.
- Supprimer les espaces au début et à la fin de la chaîne de caractères récupérée dans le tableau à la clé spécifiée.
- Après la suppression des espaces, vérifier que la chaîne de caractères n'est pas vide.
- Retourner true si toutes les conditions sont vraies, sinon retourner false.
Vous aurez besoin des fonctions prédéfinies suivantes :
- isset() : Pour vérifier qu'un élément existe.
- empty() : Pour vérifier qu'un élément est vide.
- trim() : Pour supprimer les espaces situés en début et en fin de chaîne de caractères.
- Pour obtenir plus d'informations concernant ces fonctions prédéfinies, rendez-vous sur la documentation officielle de PHP.
Exo-fonctions-11
Objectif : Créer une fonction permettant de récupérer les éventuelles erreurs d'un formulaire si les entrées utilisateurs ne respectent pas les règles définies pour les champs.
Instructions :
- Copiez le code à compléter dans votre éditeur de code :
<?php // Appliquer la déclaration stricte des types. declare(strict_types=1); /* À COMPLÉTER : Déclaration des 6 fonctions... ... ... */ // Les règles des champs du formulaires $regleDesChamps = [ 'nom' => [ 'requis' => true, 'longueurMin' => 2, 'longueurMax' => 255 ], 'email' => [ 'requis' => true, 'type' => 'email' ] ]; // Simulation d'entrées utilisateur valides provenant d'un formulaire. $entreesUtilisateurValides = [ 'nom' => 'Claudy', 'email' => 'claudy.focan@gmail.com' ]; // Simulation d'entrées utilisateur invalides provenant d'un formulaire. $entreesUtilisateurInvalides = [ 'email' => 'claudy.focan' ]; // Appeler la fonction "verifierValiditeChamps()" pour vérifier si les entrées utilisateurs respectent les règles de champ du formulaire. $erreurs = verifierValiditeChamps($regleDesChamps, $entreesUtilisateurValides); print_r($erreurs); /* Affiche : Array ( ) */ // Appeler la fonction "verifierValiditeChamps()" pour vérifier si les entrées utilisateurs respectent les règles de champ du formulaire. $erreurs = verifierValiditeChamps($regleDesChamps, $entreesUtilisateurInvalides); print_r($erreurs); /* Affiche : Array ( [nom] => Ce champs est requis! [email] => Email invalide! ) */ ?> - Copiez les 5 fonctions créées précédement estValideEmail(), respecteLongueurMinimale(), respecteLongueurMaximale(), respecteLongueurMinEtMax() et estRempli().
- Déclarez votre fonction verifierValiditeChamps() avec les deux paramètres suivants :
- $reglesDesChamps : Le tableau avec les règles des champs permettant de valider les entrées utilisateur.
- $entreesUtilisateur : Le tableau des entrées utilisateur (provenant du formulaire simulé).
- Initialiser un tableau vide $messagesErreur pour stocker les potentielles erreurs.
- Réalisez une boucle permettant d'accéder aux règles de chaque champs $regleDesChamps :
- Si la règle "requis" existe pour le champ de l'itération courante et que l'entrée utilisateur n'a pas été remplie, ajouter le message suivant "Le champ est requis!" dans le tableau $messagesErreur à la clé textuelle portant le nom du champ de l'itération courante.
- Sinon si le champ a bien été rempli, vérifier les autres règles :
- Si la règle "type" est configurée avec la valeur "email" et que l'entrée utilisateur est un email invalide, ajouter le message suivant "Email invalide!" dans le tableau $messagesErreur à la clé textuelle portant le nom du champ de l'itération courante.
- Sinon si les règles "longueurMin" et "longueurMax" sont configurées et que la longueur de l'entrée utilisateur n'est comprise entre la valeur minimale (incluse) et la valeur maximale (incluse), ajouter le message suivant "Ce champ doit doit comprendre entre {longueurMin} et {longueurMax} caractères!" dans le tableau $messagesErreur à la clé textuelle portant le nom du champ de l'itération courante.
- Sinon si la règle "longueurMin" est configurée et que la longueur de l'entrée utilisateur est inférieur à la valeur spécifiée, ajouter le message suivant "Ce champ doit comprendre au moins {longueurMin} caractères!" dans le tableau $messagesErreur à la clé textuelle portant le nom du champ de l'itération courante.
- Sinon si la règle "longueurMax" est configurée et que la longueur de l'entrée utilisateur est supérieur à la valeur spécifiée, ajouter le message suivant "Ce champ doit comprendre au maximum {longueurMin} caractères!" dans le tableau $messagesErreur à la clé textuelle portant le nom du champ de l'itération courante.
- Retourner le tableau $messagesErreur.
Fonctions de Rappel (Callbacks)
Un fonction de rappel est une fonction qui est passée en tant qu'argument à une autre fonction. Les fonctions de rappel sont utiles pour rendre votre code plus modulaire, réutilisable et flexible. Ils permettent de séparer la logique d'une fonction principale et de la personnaliser en fonction des besoins.
Prenons un exemple simple avec la fonction array_map(). Cette fonction prédéfinie prend en entrée une fonction de rappel et un ou plusieurs tableaux (nous nous concentrerons sur un seul tableau pour simplifier l'exemple). Elle parcourt le tableau et, à chaque itération, appelle la fonction de rappel en lui passant la valeur actuelle de l'élément du tableau. Enfin, array_map() retourne un nouveau tableau contenant les valeurs renvoyées par la fonction de rappel pour chaque élément traité.
<?php
declare(strict_types=1);
function doublerEntier(int $valeur): int
{
return $valeur * 2;
}
// Initialiser "$nombres" avec un tableau d'entiers.
$nombres = [1, 2, 3, 4, 5];
// La fonction prédéfinie "array_map()" va passer chaque élément contenu dans "$nombres" à la fonction de rappel "doublerEntier()".
$resultats = array_map('doublerEntier', $nombres);
print_r($resultats);
/*
Affiche :
Array
(
[0] => 2
[1] => 4
[2] => 6
[3] => 8
[4] => 10
)
*/
?>
Pour comprendre comment les opérations se déroulent dans la fonction prédéfinie array_map(), vous pouvez observer le bloc d'instructions de la fonction personnalisée appliquerSurChaqueElement(), qui en simule le comportement.
<?php
declare(strict_types=1);
function doublerEntier(int $valeur): int
{
return $valeur * 2;
}
// Voici à quoi pourrait ressembler le bloc d'instructions de la fonction prédéfinie "array_map()" :
function appliquerSurChaqueElement(callable $fonctionDeRappel, array $listeDeValeurs): array
{
$tableauDeSortie = [];
foreach($listeDeValeurs as $valeur)
{
$tableauDeSortie[] = $fonctionDeRappel($valeur);
}
return $tableauDeSortie;
}
// Initialiser $nombres avec un tableau d'entiers.
$nombres = [1, 2, 3, 4, 5];
// Appliquer la fonction de rappel "doublerEntier()" sur chaque élément du tableau à l'aide de la fonction prédéfinie array_map().
$resultats = appliquerSurChaqueElement('doublerEntier', $nombres);
print_r($resultats);
/*
Affiche :
Array
(
[0] => 2
[1] => 4
[2] => 6
[3] => 8
[4] => 10
)
*/
?>
Fonctions Anonymes
Déclaration classique
Les fonctions anonymes sont des fonctions sans nom. Elles peuvent être utilisées comme des fonctions classiques et assignées à des variables. Elles sont particulièrement utiles dans divers cas, comme la création de fonctions temporaires ou encore le passage de fonctions de rappel en argument à d'autres fonctions.
Voici un exemple de fonction anonyme utilisée en tant que fonction de rappel passée en argument de la fonction prédéfinie array_map(). Pour faciliter la lecture et la compréhension, les fonctions anonymes ne seront pas typées dans les exemples suivants :
<?php
// Initialiser $nombres avec un tableau d'entiers.
$nombres = [1, 2, 3, 4, 5];
// La fonction "array_map()" applique une fonction de rappel anonyme à chaque élément du tableau $nombres,
// doublant chaque entier. Le résultat est stocké dans la variable $resultats.
$resultats = array_map(
function($valeur) { return $valeur * 2; },
$nombres
);
print_r($resultats);
/*
Affiche :
Array
(
[0] => 2
[1] => 4
[2] => 6
[3] => 8
[4] => 10
)
*/
?>
Les fonctions fléchées
Une nouvelle fonctionnalité a été introduite avec PHP 7.4, les fonctions fléchées. Les fonctions fléchées sont des fonctions anonymes particulières qui ne prennent qu'une seule ligne d'instruction et qui en retourne le résultat automatiquement. Les fonctions fléchées se déclarent en utilisant l'opérateur fn à la place du mot-clé function :
<?php
// Initialiser $nombres avec un tableau d'entiers.
$nombres = [1, 2, 3, 4, 5];
$resultats = array_map(
fn($valeur) => $valeur * 2,
$nombres
);
print_r($resultats);
/*
Affiche :
Array
(
[0] => 2
[1] => 4
[2] => 6
[3] => 8
[4] => 10
)
*/
?>
Les closures
Une autre utilisation spécifique des fonctions anonymes est la création de closures. Les closures ont la capacité d'accéder à des variables définies à l'extérieur de leur propre bloc d'instructions, sans avoir à les passer en tant qu'arguments. Pour ce faire, ces variables doivent être explicitement transmises à la closure à l'aide de l'instruction use.
Dans l'exemple suivant, la fonction multiplier() retourne une closure, c'est-à-dire une fonction anonyme qui conserve l'accès à une variable de l'environnement où elle a été créée, même après avoir été retournée et utilisée ailleurs.
Plus concrètement, la variable $doublerNombre est initialisée avec une closure retournée par multiplier(2), ce qui signifie que cette closure "souvient" du facteur de multiplication 2. Chaque fois que la variable $doublerNombre() est appelée avec un nombre en argument, elle multiplie ce nombre par 2.
L'intérêt d'une telle approche réside dans sa flexibilité et sa réutilisabilité. Au lieu de créer une fonction spécifique pour chaque facteur de multiplication, on peut créer une fonction générique (comme multiplier()) et l'utiliser pour générer des fonctions qui effectuent des multiplications avec différents facteurs.
<?php
function multiplier($facteur)
{
// La fonction "multiplier()" retourne une closure :
return function($nombre) use ($facteur)
{
return $nombre * $facteur;
};
}
// Déclaration et initialisation de la variable "$doubler_nombre()" avec la création d'une closure ayant un facteur de multiplication de 2.
$doublerNombre = multiplier(2);
// Utilisation de la closure pour multiplier un nombre par deux.
$resultat = $doublerNombre(5);
echo $resultat; // Affiche : 10
?>
Dans le cas des closures, les fonctions fléchées capturent automatiquement les variables de la portée environnante (comme le faisait l'instruction use dans l'exemple précédent) :
<?php
function multiplier($facteur)
{
// La fonction "multiplier()" retourne une closure :
return fn($nombre) => $nombre * $facteur;
}
// Déclaration et initialisation de la variable "$doubler_nombre()" avec la création d'une closure ayant un facteur de multiplication de 2.
$doubler_nombre = multiplier(2);
// Utilisation de la closure pour multiplier un nombre par deux.
$resultat = $doubler_nombre(5);
echo $resultat; // Affiche : 10
?>
Les closures peuvent aussi être utilisées pour encapsuler des variables et maintenir un état interne, simulant ainsi le comportement des objets avec des propriétés :
<?php
function compteur()
{
$compteur = 0;
// Utilisation du symbole de référence explicite "&" :
return function() use (&$compteur)
{
return ++$compteur;
};
}
$incrementer = compteur();
echo $incrementer(); // Affiche : 1
echo $incrementer(); // Affiche : 2
echo $incrementer(); // Affiche : 3
?>
Notez que les fonctions fléchées ne prennent pas en charge les références explicites avec le symbole &.
Fonctions Prédéfinies de Tableau
Après avoir exploré les concepts des fonctions de rappel et des fonctions anonymes, nous sommes prêts à plonger dans le monde des fonctions prédéfinies de tableau qui prennent une fonction de rappel en argument. Ces fonctions vous permettent de manipuler efficacement les tableaux, de filtrer, de transformer et d'effectuer diverses opérations sur leurs éléments.
-
array_map() : Cette fonction permet d'utiliser une fonction de rappel en argument pour transformer chaque élément du tableau d'origine en créant un nouvel élément dans le nouveau tableau résultant.
Elle possède 2 paramètres :
- 1er paramètre : Le talbeau dont on veut appliquer une fonction de rappel sur chacun des éléments.
- 2ème paramètre : Une fonction de rappel qui détermine les instructions qui seront appliquées sur les éléments du tableau.
<?php $nombres = [1, 2, 3, 4, 5]; function multiplierParDeux(int $nombre): int { return $nombre * 2; } // Doubler chaque nombre dans le tableau. $nombresDoubles = array_map('multiplierParDeux', $nombres); print_r($nombresDoubles); /* Affiche : Array ( [0] => 2 [1] => 4 [2] => 6 [3] => 8 [4] => 10 ) */ ?>Nous aurions également pu opter pour une version plus concise avec une fonction fléchée.
<?php $nombres = [1, 2, 3, 4, 5]; $multiplierParDeux = fn($nombre) => $nombre * 2; // Doubler chaque nombre dans le tableau. $nombresDoubles = array_map('multiplierParDeux', $nombres); print_r($nombresDoubles); /* Affiche : Array ( [0] => 2 [1] => 4 [2] => 6 [3] => 8 [4] => 10 ) */ ?>Si une fonction de rappel n'a besoin d'être utilisée qu'une seule fois, elle peut être définie directement en tant qu'argument :
<?php $nombres = [1, 2, 3, 4, 5]; // Doubler chaque nombre dans le tableau. $nombresDoubles = array_map(fn($nombre) => $nombre * 2, $nombres); print_r($nombresDoubles); /* Affiche : Array ( [0] => 2 [1] => 4 [2] => 6 [3] => 8 [4] => 10 ) */ ?> -
array_filter() : Cette fonction permet de filtrer les éléments d'un tableau en fonction d'une condition définie dans une fonction de rappel. Elle crée un nouveau tableau contenant tous les éléments pour lesquels la fonction de rappel renvoie true.
Elle possède 2 paramètres :- 1er paramètre : Le talbeau dont on veut filtrer les éléments.
- 2ème paramètre : Une fonction de rappel qui détermine la façon dont les éléments seront filtrés.
<?php $nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; // Filtrer les nombres pairs. $nombrespairs = array_filter($nombres, fn($nombre) => $nombre % 2 === 0); /* Valeur du filtre à chaque itération : nombre => nombre % 2 === 0 résultat : tableau de sortie ---------------------------------------------------------------------------------- 1ère itération : 1 => 1 % 2 === 0 false : ignoré 2ème itération : 2 => 2 % 2 === 0 true : ajouté 3ème itération : 3 => 3 % 2 === 0 false : ignoré ... */ print_r($nombrespairs); /* Affiche : Array ( [0] => 2 [1] => 4 [2] => 6 [3] => 8 [4] => 10 ) */ ?> -
array_reduce() : Cette fonction est utilisée pour accumuler les éléments d'un tableau.
Elle possède 2 paramètres :- 1er paramètre : Le talbeau dont on veut accumuler les éléments.
- 2ème paramètre : Une fonction de rappel qui détermine la façon dont les éléments sont accumulés.
- 3ème paramètre (facultatif) : La valeur initiale de l'accumulateur. Si celle-ci n'est pas précisée, la valeur initiale prendra la première valeur du tableau.
- 1er paramètre : L'accumulateur est soit la valeur retournée par l'appel précédent de la fonction de rappel, soit la valeur initiale fournie si c'est le premier appel.
- 2ème paramètre : La valeur de l'élement actuel.
<?php $nombres = [1, 2, 3, 4, 5]; // Calculer la somme de tous les nombres dans le tableau. $somme = array_reduce($nombres, fn($acc, $nombre) => $acc + $nombre, 0); /* Valeur de l'accumulateur à chaque itération : acc = acc + nombre résultat ----------------------------------------------- 1ère itération : acc = 0 + 1 1 2ème itération : acc = 1 + 2 3 3ème itération : acc = 3 + 3 6 4ème itération : acc = 6 + 4 10 5ème itération : acc = 10 + 5 15 */ print_r($somme); // Affiche : 15 ?> -
usort() : Cette fonction permet de trier un tableau en utilisant une fonction de comparaison définie par l'utilisateur. Contrairement à des fonctions comme sort(), qui utilisent l'ordre naturel, usort() vous donne un contrôle total sur la manière dont les éléments sont comparés. Attention, le tableau d'origine est passé par référence, il sera donc modifié par le résultat.
Elle possède 2 paramètres :- 1er paramètre : Le tableau que l'on souhaite trier.
- 2ème paramètre : Une fonction de rappel qui compare les éléments du tableau. Cette fonction, appelée par usort(), doit lui retourner l'une des trois valeurs suivantes :
- Un entier négatif : Le premier élément est considéré comme plus petit, il est placé avant le second.
- 0 : Les deux éléments sont considérés comme égaux et leur ordre ne bouge pas.
- Un entier positif : Le premier élément est considéré comme plus grand, il est placé après le second.
Pour des tris simples, comme trier un tableau par ordre alphabétique ou numérique, deux fonctions prédéfinies, faciles à utiliser et ne nécessitant pas de fonction de rappel, sont disponibles. La fonction sort() permet de trier dans l'ordre croissant, tandis que rsort() trie dans l'ordre décroissant.<?php $mots = ['Jean-Luc', 'Claudy', 'Bob', 'Hervé']; // Trier les mots en fonction de leur longueur, du plus petit au plus grand : usort( $mots, fn($a, $b) => mb_strlen($a) - mb_strlen($b) ); print_r($mots); /* Affiche : Array ( [0] => Bob [1] => Hervé [2] => Claudy [3] => Jean-Luc ) */ ?>
Nous n'allons pas voir toutes ces fonctions en détails mais si vous désirez obtenir plus d'informations sur le sujet, rendez-vous sur le site officiel de PHP.
Fonctions Récursives
Les fonctions récursives sont des fonctions qui s'appellent elles-mêmes pour résoudre un problème de manière itérative. Les fonctions récursives sont couramment utilisées pour résoudre des problèmes qui peuvent être divisés en sous-problèmes identiques ou similaires.
Une fonction récursive suit généralement cette structure de base :
- Condition de base (cas de base) : Une déclaration conditionnelle qui vérifie si la fonction doit s'arrêter ou renvoyer une valeur directe. C'est la base de la récursivité pour éviter une boucle infinie.
- Appel récursif : La fonction appelle elle-même avec des paramètres différents pour résoudre une partie plus petite du problème. Cette étape est importante pour converger vers le cas de base.
Nous allons créer une fonction récursive qui calculera la somme des entiers naturels de 1 à n. Nous utiliserons la récursion pour décomposer le calcul en sous-problèmes plus simples jusqu'à ce que la somme totale soit obtenue :
<?php
function calculerSommeArithmetique(int $n): int
{
// Cas de base : si $n est égal à 1, retourne simplement 1.
if ($n === 1)
{
return 1;
}
// Retourne la somme du terme courant ($n) et de la somme des termes précédents.
// En appelant récursivement la fonction avec ($n - 1), nous ajoutons chaque terme
// de la suite jusqu'à ce que nous atteignions le cas de base.
// Cette approche accumule la somme des nombres de 1 jusqu'à $n.
return $n + calculerSommeArithmetique($n - 1);
}
// Calcule la somme des nombres de 1 à 5.
$n = 5;
$somme = calculerSommeArithmetique($n);
echo "La somme arithmétique des nombres de 1 à $n est $somme."; // Affiche : La somme arithmétique des nombres de 1 à 5 vaut 15.
?>
Documenter son Code avec PHPDoc
Il est possible d'utiliser une technique plus précise et structurée pour documenter une fonction, ce qui présente plusieurs avantages, notamment pour la lisibilité, la maintenance et la génération automatique de documentation. Voici une version améliorée de la documentation PHP (PHPDoc) pour la fonction :
<?php
// Appliquer la déclaration stricte des types.
declare(strict_types=1);
/**
* Calcule et affiche le double d'une valeur entière ou flottante.
*
* @param float (nombre flottant ou un entier qui sera converti en flottant) $valeur La valeur devant être doublée.
*
* @return void (vide) La fonction affiche la valeur doublée mais ne renvoie pas de valeur en dehors de son bloc.
*/
function afficherLeDouble(float $valeur): void
{
// Afficher le double de la valeur passée en argument.
echo ($valeur * 2);
}
// Appel de la fonction afficherLeDouble() avec l'entier 5 en argument.
afficherLeDouble(5); // Affiche : 10
?>
Exercices - Part 02
Exo-fonctions-12 (notions avancées : fonctions récursives)
Objectif : Créer une fonction récursive permettant de générer la suite de Fibonacci jusqu'au n-ième terme. En mathématiques, la suite de Fibonacci est une série de nombres entiers où chaque nombre est la somme des deux précédents, en commençant par 0 et 1. Les dix premiers termes sont : 0, 1, 1, 2, 3, 5, 8, 13, 21 et 34.
Instructions :
- Copiez le code à compléter dans votre éditeur de code :
<?php // Appliquer la déclaration stricte des types. declare(strict_types=1); /* À COMPLÉTER : Déclaration de la fonction... ... ... */ // Générer les 10 premiers termes de la suite de Fibonacci. $n = 10; $suiteFibo = genererSuiteFibonacci($n); // Afficher le résultat de la suite de Fibonacci. echo "Suite de Fibonacci jusqu'au terme F($n) : " . PHP_EOL; print_r($suiteFibo); /* Affiche : Suite de Fibonacci jusqu'au terme F(10) : Array ( [0] => 0 [1] => 1 [2] => 1 [3] => 2 [4] => 3 [5] => 5 [6] => 8 [7] => 13 [8] => 21 [9] => 34 ) */ ?> - Déclarer la fonction genererSuiteFibonacci() avec au moins un paramètre (vous pouvez en ajouter autant que vous le souhaitez) :
- $n : Le nombre de termes à générer dans la suite de Fibonacci (incluant les deux premiers termes : 0 et 1).
- N'oubliez pas de configurer la condition permettant d'arrêter les récursions et de retourner les valeurs, sans quoi votre fonction continuera de s'appeler indéfiniment, ce qui entraînera une erreur de dépassement de pile ("stack overflow").
- Retournez le tableau contenant les $n premières valeurs de la suite de Fibonacci