Découper un programme en morceaux
Quand un programme grandit, il devient difficile à lire. La solution des programmeurs : le découper en petits morceaux qui font chacun une seule chose, et leur donner un nom.
Un programme d'un seul bloc
Ce programme affiche le bulletin d'un élève. Il fonctionne, mais tout est mélangé :
notes est un tableau vaut [12, 15, 9, 18]
total est un nombre vaut 0
pour i de 0 à longueur(notes) - 1
total ajoute notes[i]
fin pour
moyenneEleve est un nombre
moyenneEleve vaut total / longueur(notes)
affiche '===================='
affiche 'Bulletin de Léa'
affiche '===================='
affiche 'Moyenne : ' + decimal(moyenneEleve, 1)
si moyenneEleve >= 16 alors
affiche 'Mention : très bien'
sinon si moyenneEleve >= 12 alors
affiche 'Mention : bien'
sinon si moyenneEleve >= 10 alors
affiche 'Mention : passable'
sinon
affiche 'Mention : insuffisant'
fin si
Trois tâches différentes s'y cachent : calculer la moyenne, choisir la mention, afficher le bulletin. Et pour un deuxième élève, il faudrait tout recopier.
Étape 1 : repérer les morceaux
On se pose une question pour chaque groupe de lignes : « à quoi ça sert ? ». Si la réponse tient en une phrase, c'est un bon candidat :
- « Calculer la moyenne d'une liste de notes » : une fonction, elle renvoie un nombre.
- « Trouver la mention qui correspond à une moyenne » : une fonction, elle renvoie un texte.
- « Afficher le bulletin d'un élève » : une procédure, elle fait une action.
Question : « Dessiner le titre du jeu à l'écran » : fonction ou procédure ? — Une procédure. Il n'y a pas de résultat à renvoyer : c'est une action, donc une procédure.
Étape 2 : écrire les morceaux
// Renvoie la moyenne d'un tableau de notes
fonction calculerMoyenne(liste)
total est un nombre vaut 0
pour i de 0 à longueur(liste) - 1
total ajoute liste[i]
fin pour
retourne total / longueur(liste)
fin fonction
// Renvoie la mention qui correspond à une moyenne
fonction trouverMention(valeur)
si valeur >= 16 alors
retourne 'très bien'
fin si
si valeur >= 12 alors
retourne 'bien'
fin si
si valeur >= 10 alors
retourne 'passable'
fin si
retourne 'insuffisant'
fin fonction
// Affiche le bulletin complet d'un élève
procédure afficherBulletin(prenom, liste)
resultat est un nombre vaut calculerMoyenne(liste)
affiche '===================='
affiche 'Bulletin de ' + prenom
affiche '===================='
affiche 'Moyenne : ' + decimal(resultat, 1)
affiche 'Mention : ' + trouverMention(resultat)
fin procédure
// Programme principal
notesLea est un tableau vaut [12, 15, 9, 18]
notesTom est un tableau vaut [8, 11, 7, 10]
appelle afficherBulletin('Léa', notesLea)
appelle afficherBulletin('Tom', notesTom)
Le programme principal tient maintenant en quatre lignes, et il se lit comme une phrase. Ajouter un élève ne demande que deux lignes de plus.
Ce qu'on a gagné
- Lisible : chaque morceau a un nom qui dit ce qu'il fait.
- Réutilisable :
calculerMoyenne peut servir ailleurs, pour une classe entière par exemple. - Facile à corriger : si la mention est fausse, on sait qu'il faut regarder
trouverMention, et nulle part ailleurs. - Facile à tester : on peut vérifier chaque fonction séparément.
Les bons réflexes
- Une fonction fait une seule chose. Si son nom contient « et », elle en fait sûrement deux.
- Son nom commence par un verbe :
calculer, trouver, afficher, verifier. - Elle reçoit ses données par ses paramètres plutôt que de lire les variables du programme principal.
- Elle tient sur un écran : au-delà d'une trentaine de lignes, on la découpe encore.
On appelle ce travail la décomposition. C'est la compétence la plus importante en programmation : on ne résout pas un gros problème, on résout plusieurs petits problèmes.
En résumé
- Un long programme se découpe en morceaux qui font chacun une seule chose.
- Un résultat à renvoyer : une fonction. Une action à faire : une procédure.
- Le programme principal devient court et se lit comme un sommaire.
- Chaque morceau peut être testé, corrigé et réutilisé séparément.
