Module Dart.5 – Fonctions

Objectif

Maîtriser les fonctions Dart : déclaration, paramètres (positionnels, nommés, optionnels), fonctions fléchées, et toutes les variantes pour créer du code réutilisable.

Théorie

Déclaration de fonction

Structure de base :

typeRetour nomFonction([paramètres]) {
    // Code
    return valeur;  // Si typeRetour n'est pas void
}

Exemple simple :

void saluer() {
    print('Bonjour !');
}

Fonction avec paramètres :

void saluer(String nom) {
    print('Bonjour $nom');
}

Fonction avec retour :

int additionner(int a, int b) {
    return a + b;
}

Paramètres positionnels

Paramètres dans l'ordre défini.

void afficher(String nom, int age) {
    print('$nom a $age ans');
}

afficher('Jean', 30);  // Ordre important

Paramètres optionnels

Paramètres optionnels positionnels

Entre crochets [], avec valeur par défaut possible.

void afficher(String nom, [int? age]) {
    if (age != null) {
        print('$nom a $age ans');
    } else {
        print('$nom (âge inconnu)');
    }
}

afficher('Jean');        // Jean (âge inconnu)
afficher('Jean', 30);    // Jean a 30 ans

Avec valeur par défaut :

void saluer(String nom, [String langue = 'fr']) {
    if (langue == 'fr') {
        print('Bonjour $nom');
    } else if (langue == 'en') {
        print('Hello $nom');
    }
}

saluer('Jean');           // Bonjour Jean
saluer('Jean', 'en');     // Hello Jean

Paramètres nommés

Entre accolades {}, appelés par nom.

void creerPersonne({required String nom, int age = 0}) {
    print('$nom a $age ans');
}

creerPersonne(nom: 'Jean', age: 30);
creerPersonne(age: 25, nom: 'Marie');  // Ordre n'importe pas
creerPersonne(nom: 'Pierre');           // age = 0 par défaut

required : Paramètre obligatoire (même s'il est nommé).

Sans required :

void afficher({String? nom, int? age}) {
    print('Nom: ${nom ?? "Inconnu"}, Age: ${age ?? 0}');
}

afficher();              // OK : tous optionnels
afficher(nom: 'Jean');   // OK

Fonctions fléchées

Syntaxe concise pour fonctions courtes.

Syntaxe :

int additionner(int a, int b) => a + b;

// Équivalent à :
int additionner(int a, int b) {
    return a + b;
}

Exemples :

int carre(int x) => x * x;
String saluer(String nom) => 'Bonjour $nom';
bool estPair(int n) => n % 2 == 0;

Limitation : Une seule expression, pas de bloc.

Paramètres variadiques

Dart n'a pas de varargs comme Java, mais on peut utiliser des listes.

int additionner(List<int> nombres) {
    return nombres.fold(0, (sum, n) => sum + n);
}

additionner([1, 2, 3, 4, 5]);  // 15

Return

Retour simple :

int calculer() {
    return 42;
}

Retour multiple (via objet) :

class Resultat {
    final int valeur;
    final String message;
    
    Resultat(this.valeur, this.message);
}

Resultat calculer() {
    return Resultat(42, 'Succès');
}

Pas de return (void) :

void afficher() {
    print('Test');
    // Pas de return nécessaire
}

Return prématuré :

int? trouver(List<int> nombres, int valeur) {
    for (int n in nombres) {
        if (n == valeur) {
            return n;  // Sort immédiatement
        }
    }
    return null;  // Non trouvé
}

Fonctions anonymes

Fonctions sans nom, souvent utilisées comme callbacks.

var saluer = (String nom) {
    print('Bonjour $nom');
};

saluer('Jean');

Avec arrow function :

var additionner = (int a, int b) => a + b;

Fonctions d'ordre supérieur

Fonctions qui prennent d'autres fonctions en paramètre.

void appliquer(List<int> nombres, Function(int) action) {
    for (int n in nombres) {
        action(n);
    }
}

appliquer([1, 2, 3], (n) => print(n * 2));

Avec typage :

void appliquer(List<int> nombres, void Function(int) action) {
    for (int n in nombres) {
        action(n);
    }
}

Closures

Fonction qui a accès aux variables de son scope parent.

Function creerCompteur() {
    int count = 0;
    
    return () {
        count++;
        return count;
    };
}

var compteur = creerCompteur();
compteur();  // 1
compteur();  // 2
compteur();  // 3

Exercice

1. Fonctions de base

   • Créez des fonctions avec différents types de retour
   • Testez avec différents paramètres
   • Utilisez return

2. Paramètres

   • Créez des fonctions avec paramètres positionnels
   • Testez les paramètres optionnels
   • Utilisez les paramètres nommés

3. Fonctions fléchées

   • Convertissez des fonctions en arrow functions
   • Testez la syntaxe courte
   • Comprenez les limitations

4. Fonctions d'ordre supérieur

   • Créez des fonctions qui prennent des fonctions
   • Utilisez avec forEach, map, where
   • Testez les closures

5. Cas pratiques

   • Créez une bibliothèque de fonctions utilitaires
   • Utilisez différents types de paramètres
   • Testez toutes les variantes

Quiz

1. Comment déclarer un paramètre nommé obligatoire ?

   • String nom
   • required String nom
   • final String nom

2. Quelle est la différence entre paramètres positionnels et nommés ?

   • Aucune différence
   • Positionnels : ordre important, nommés : appelés par nom
   • Nommés sont plus rapides

3. Que sont les fonctions fléchées ?

   • Fonctions anonymes
   • Syntaxe courte pour fonctions (=>)
   • Fonctions asynchrones

4. Que fait required ?

   • Rend la fonction requise
   • Rend le paramètre nommé obligatoire
   • Optimise la fonction

5. Qu'est-ce qu'une closure ?

   • Fonction anonyme
   • Fonction avec accès aux variables du scope parent
   • Fonction globale

Mini défi

Mission : Créer une bibliothèque de fonctions utilitaires

Créez une classe MathUtils avec des fonctions static :

Fonctions :

1. Opérations de base (additionner, multiplier avec paramètres variadiques)
2. Calculs avancés (puissance, racine)
3. Statistiques (moyenne, max, min avec listes)
4. Utilitaires (arrondir, formater)

Critères :

• ✅ Utilisation de différents types de paramètres
• ✅ Fonctions fléchées où approprié
• ✅ Gestion d'erreurs
• ✅ Documentation dartdoc

Objectif : Maîtriser toutes les formes de fonctions Dart et créer une bibliothèque réutilisable.

---

Validation : Vous pouvez passer au module suivant quand vous maîtrisez les fonctions, paramètres et closures.