Dart en 10 chapitres : Chap 5 Fonctions.
Salut, espérant que vous allez bien, ravi de vous revoir encore avec nous.
Nous avançons toujours doucement et sûrement vers notre trésor caché🤗
Après avoir eu à voir les différentes structures à savoir les structures conditionnelles et les structures itératives.
0. Vue d’ensemble
Dans ce chapitre, nous verrons :
a. C’est quoi une fonction
b. Comment déclarer une fonction en Dart
c. Comment appeler une fonction en Dart
d. Les fonctions paramétrées en Dart
e. Types de Paramètres
f. Conclusion
1. Qu’est-ce qu’une fonction
Une fonction est un bloc de code autonome qui peut être appelé et réutilisé dans un programme.
Elle est créée pour une tâche spécifique (Donc une fonction créée dans un programme n’exécutera qu’une et une seule tâche qu’on lui a attribuée et cela autant de fois qu’elle est appelée).
Ses grands avantages sont :
- réutilisabilité : permet de regrouper du code et de l’utiliser plusieurs fois.
- modularité : décompose le code en modules plus petits et plus faciles à gérer.
- lisbilité : améliore la lisibilité du code en regroupant les instructions logiquement liées.
- testabilité : facilite le test et la maintenance du code.
Comprenons par un exemple simple, si tu dois faire une calculatrice arithmétique, c-à-d avec les opérations ( + , — , * , / ), tu peux créer juste une fonction pour chacune des opérations, ainsi la fonction récupérera les valeurs entrées par l’utilisateur puis renvoie le résultat. Ainsi ton code sera facilement lisible et modulaire, en sachant juste où est la fonction qui fait telle ou telle autre opération, facile à maintenir si il y a un souci de calcul on a qu’à aller juste à la fonction de l’opération puis modifier.
2. Déclaration d’une fonction
Pour déclarer une fonction, commençons par donner les éléments clés d’une fonction :
- Nom de la fonction: Identifie la fonction et doit être unique dans le programme.
- Paramètres: Les valeurs que la fonction reçoit lors de son appel.
- Type de retour: Le type de la valeur que la fonction retourne après son exécution.
- Corps de la fonction: Les instructions qui sont exécutées lorsque la fonction est appelée.
Ainsi, en déclarant une fonction, nous signalons au compilateur le nom de la fonction, le type de valeur que la fonction retourne après son exécution et les paramètres qu’elle prendra à chaque appel.
Ainsi, la première syntaxe d’une fonction est la suivante :
nom_fonction(){
//instructions
}La deuxième syntaxe est celle des fonctions de retour, on ajoute au début le type de valeur qu’elle retourne et à la fin des instructions vient sa valeur à retourner et celle-ci sera du type précédemment déclaré :
//On peut avoir plusieurs types comme int, void, ...
//Cette fonction retourne un type entier
int nom_fonction(){
//instructions
//La valeur à retourner, dans notre cas un type int
return valeur;
}Le type void veut dire que la fonction ne retourne aucune valeur.
Notons pour l’instant qu’une fonction ne retourne qu’une et une seule valeur.
3. Appel d’une fonction
Pour qu’une fonction soit utilisée, elle est appelée dans le programme à l’endroit voulue. Voyons comment l’appel d’une fonction se fait.
La syntaxe est la suivante :
//Les paramètres, si elles existent, sont mises à l'intérieur des parathèses
nom_fonction();4. Fonctions paramétrées
Ceux-ci sont des fonctions qui, à leur tour, peuvent accepter des valeurs au moment de leur appel dans le programme.
Ces valeurs sont appelées paramètres et elles sont passées à la fonction lors de l’appel de celle-ci.
Si il n’y a pas d’indication contraire que le programmeur ajoute selon ses attentes, le nombre des valeurs à entrer est obligatoirement égal au nombre des paramètres de la fonction.
La syntaxe est la suivante :
//Le nombre des paramètres n'est pas limité
type_de_retour nom_fonction(type_paramètre1 nom_paramètre1, type_paramètre2 nom_paramètre2, ...){
//instructions
return valeur //si il y en a
}Avec ces notions, nous pouvons prendre notre exemple du début, celui d’une calculatrice, et faire une démo avec :
//Exemple sur la notion de fonction en Dart
/*Fonction du type int avec comme tache d'additionner
les deux valeurs entrées en paramètres, automatiquement
elle retourne un int*/
int addition(int nombre1, int nombre2) {
return nombre1 + nombre2;
}
/*Fonction du type int avec comme tache de soustraire
les deux valeurs entrées en paramètres, automatiquement
elle retourne un int*/
int soustraction(int nombre1, int nombre2) {
return nombre1 - nombre2;
}
/*Fonction du type int avec comme tache de multiplier
les trois valeurs entrées en paramètres, automatiquement
elle retourne un int*/
int multiplication(int nombre1, int nombre2, int nombre3) {
return nombre1 * nombre2 * nombre3;
}
/*Fonction du type double car le résultat d'une division peut être
soit entier soit décimal, avec comme tache de diviser les deux
valeurs entrées en paramètres, automatiquement
elle retourne un double*/
double division(int nombre1, int nombre2) {
return nombre1 / nombre2;
}
/*Fonction du type void, donc ne retourner aucune valeur,
avec comme tache d'afficher juste la valeur entrée en paramètres,
qui est un message du type String*/
void afficherMessage(String message) {
print(message);
}
//Notre grande fonction main qui est celle principale dans l'exécution d'un programme
void main() {
/*Appels des fonctions précédement déclarées avec les paramètres passés
leurs valeurs stockers dans une variable avant d'être afficher par
la fonction d'affichage*/
int resultatAddition = addition(10, 20);
int resultatSoustraction = soustraction(10, 20);
int resultatMultiplication = multiplication(4, 3, 2);
double resultatDivision = division(10, 3);
afficherMessage("Le résultat d'addition vaut $resultatAddition");
afficherMessage("Le résultat de la soustraction vaut $resultatSoustraction");
afficherMessage("Le résultat de la multiplication vaut $resultatMultiplication");
afficherMessage("Le résultat de la division vaut $resultatDivision");
}
//On peut aussi afficher ses fonctions directement dans celle d'affichage
void main() {
afficherMessage("Le résultat d'addition vaut ${addition(10, 20)}");
afficherMessage("Le résultat de la soustraction vaut ${soustraction(10, 20)}");
afficherMessage("Le résultat de la multiplication vaut ${multiplication(4, 3, 2)}");
afficherMessage("Le résultat de la division vaut ${division(10, 3)}");
}
Il y a des fonctions dit fonctions fléchées, elles permettent une syntaxe plus concise pour les fonctions simples, utilisant =>.
A noter qu’elles ne sont pas capables de tout comme les fonctions normales, elles sont utilisées pour des fonctions n’ayant pas plusieurs instructions à réaliser.
Dans notre exemple précédent, prenons le cas de la fonction d’affichage, elle peut s’écrire aussi de la manière suivante :
void afficherMessage(String message) => print(message);5. Types de paramètres
Il existe 2 grands types de paramètres pour les fonctions en Dart :
- les paramètres obligatoires
- les paramètres facultatifs
a. Les paramètres obligatoires
On en parlera pas ici, car ce sont ceux vus précédemment, donc les paramètres dans leur état initial dans les fonctions en Dart.
b. Les paramètres facultatifs
Les paramètres facultatifs quant à eux, comme dit leur nom, sont des paramètres utilisés quand l’argument à passer à la fonction n’est pas nécessaire à chaque appel de la fonction.
Pour se faire, on utilise un point d’interrogation (?) après le type du paramètre facultatif.
Un paramètre facultatif doit venir à la dernière position parmi les paramètres d’une fonction si il y a ceux qui ne le sont pas.
Parmi ces paramètres, nous avons :
- Les paramètres facultatifs positionnels : utilisent les brackets [ ] pour la déclaration.
nom_fonction(paramètre1, [paramètre2, paramètres3, ...]){
//instructions
}Notons ici que si aucune valeur n’est passé à l’appel, la valeur de ces paramètres sera nulle.
//Une fonction avec les params facultatifs positionnels
void afficherInfo(String nom, [int? age, String? ville]) {
print("Nom : $nom");
print("Age : $age");
print("Ville : $ville");
print("\n");
}
void main() {
//Vu qu'il n'y a pas de valeurs pour l'âge et la ville, ces 2 params auront null comme valeur
afficherInfo("Georges");
//Ici la valeur d'âge est ajoutée, donc ce n'est que la ville qui a un null
afficherInfo("Georges", 20);
//Et ici, tous les params ont une valeur
afficherInfo("Georges", 20, 'Bunia');
}
- Les paramètres facultatifs nommés : ceux-ci doivent être spécifiés par leur nom lors de l’appel de la fonction. Ils utilisent les accolades { }.
nom_fonction(paramètre1, {paramètre2, paramètres3, ...}){
//instructions
}//Une fonction avec les params facultatifs nommés
void afficherInfo(String nom, {int? age, String? ville}) {
print("Nom : $nom");
print("Age : $age");
print("Ville : $ville");
print("\n");
}
void main() {
//Vu qu'il n'y a pas de valeurs pour l'âge et la ville, ces 2 params auront null comme valeur
afficherInfo("Georges");
//Ici la valeur d'âge est ajoutée, donc ce n'est que la ville qui a un null
afficherInfo("Georges", age : 20);
//Et ici, tous les params ont une valeur
afficherInfo("Georges", ville : 'Bunia', age : 20);
}
Notons ici que la place de valeur des paramètres n’est pas recommandée, juste le nom du paramètre et sa valeur, contrairement aux positionnels qui n’acceptent pas le renversement de la place de valeur des paramètres.
- Les paramètres facultatifs avec une valeur par défaut
nom_fonction(paramètre1, [paramètre2 = valeur_par_défaut, paramètres3 = valeur_par_défaut, ...]){
//instructions
}Notons qu’on peut passer les valeurs par défaut et pour les paramètres facultatifs positionnels et pour les nommés.
//Une fonction avec les params facultatifs nommés avec valeur par défaut
void afficherInfo(String nom, {int? age = 20, String? ville = 'Bunia'}) {
print("Nom : $nom");
print("Age : $age");
print("Ville : $ville");
print("\n");
}
void main() {
//Vu qu'il n'y a pas de valeurs pour l'âge et la ville, ces 2 params auront les valeurs par défaut comme valeur
afficherInfo("Georges");
//Ici la valeur d'âge est ajoutée, donc ce n'est que la ville qui garde sa valeur par défaut
afficherInfo("Georges", age : 18);
//Et ici, tous les params ont une valeur, et les valeurs par défaut ne sont plus lues
afficherInfo("Georges", ville : 'Bukavu', age : 18);
}
Constat fait : la valeur par défaut est lue jusqu’à l’affectation d’une nouvelle valeur.
6. Conclusion
Sous ce chapitre, il a été question de dissiper les lacunes sur la notion des fonctions en programmation dans son général et plus particulièrement en Dart en parlant des points tels que la déclaration et l’appel d’une fonction en Dart, les fonctions paramétrées en Dart, et pour chuter avec les types des fonctions en Dart.
Merci encore pour ce pas de plus dans cette course.
Je vous dis merci et à la prochaine.
N’oubliez pas : “Ne limitez pas vos rêves !”.
😉
