3.1Procédures locales, globales & collections de procédures
L'essentiel en 30 secondes
- Une procédure est un bloc nommé et réutilisable : locale à une fenêtre, globale au projet, ou regroupée dans une collection par thème.
- Paramètres et valeur de retour rendent une procédure générique ; le passage par valeur travaille sur une copie, le passage par référence modifie l'original.
- Une procédure = une responsabilité et un nom explicite ; on limite les variables globales et on transforme tout copier-coller en procédure.
Mini-cas filé — Yacine factorise les calculs de sa gestion
Yacine développe l'application de gestion d'une PME de négoce de matériel électrique à Oran : clients, produits, commandes, factures et stocks. Il a copié-collé le calcul de remise fidélité dans trois écrans, et chaque changement de taux l'oblige à corriger trois fois. Il crée CalculeRemiseFidelite et CalculeMontantTTC comme procédures globales, regroupées dans la collection GestionCommerciale. À l'inverse, RéinitialiseSaisie reste une procédure locale à la fenêtre de commande, car elle ne sert que là. Il remplace aussi ses variables globales par des paramètres et des valeurs de retour. Il note le réflexe : duplication = procédure, portée selon l'usage, collection par thème.
Cas autonome de cette section : il revient dans le cours, le schéma, le script et le défi 48h de la section 3.1.
1. Trois portées, trois usages
Une procédure est un bloc de code nommé et réutilisable : on l'écrit une fois, on l'appelle autant de fois que nécessaire. Sa portée dépend de l'endroit où elle est déclarée. La procédure locale appartient à une fenêtre ou à un état : elle n'est utilisable que dans cet écran. La procédure globale est déclarée au niveau du projet et accessible partout : c'est là que vivent les règles métier réutilisables. La collection de procédures regroupe des procédures par thème (calculs commerciaux, utilitaires de dates, accès à un service) : c'est l'organisation naturelle d'un projet qui grandit.
2. Paramètres, valeur et référence
Une procédure reçoit des paramètres — les données dont elle a besoin — et peut renvoyer une valeur : on parle alors souvent de fonction. Le passage par valeur transmet une copie : la procédure peut modifier son paramètre sans toucher à la variable d'origine. Le passage par référence transmet la variable elle-même : la procédure peut la modifier. Confondre les deux est une source classique de bugs, surtout quand Yacine croit qu'un total a été mis à jour alors qu'il travaillait sur une copie.
3. Qualité : une responsabilité, un nom
Une bonne procédure fait une seule chose et porte un nom explicite qui la décrit : CalculeMontantTTC, ControleCodePostal. Elle reste courte, reçoit ce dont elle a besoin par paramètres et renvoie son résultat. On limite les variables globales, car n'importe quel écran peut les modifier et rendre le comportement imprévisible. Enfin, dès que Yacine s'apprête à copier-coller du code, il en fait une procédure : c'est le signal le plus fiable.
🔎 Exemple concret — 🔎 Exemple concret — Deux procédures globales, un seul calcul
Yacine regroupe les règles commerciales dans la collection GestionCommerciale :
// Collection GestionCommerciale — procédures globales
PROCEDURE CalculeMontantTTC(nMontantHT est un monetaire, nTauxTVA est un reel = 19)
RENVOIE nMontantHT * (1 + nTauxTVA / 100)
PROCEDURE CalculeRemiseFidelite(nCA est un monetaire, nAnciennete est un entier)
SI nAnciennete >= 5 ALORS
RENVOIE nCA * 0.05
FIN
RENVOIE 0
// Fenêtre FicheCommande : appel explicite, sans variable globale
nTTC est un monetaire = CalculeMontantTTC(SAI_MontantHT, 19)
nRemise est un monetaire = CalculeRemiseFidelite(CLI_CA, CLI_Anciennete)Lecture : la règle est écrite une seule fois et appelée depuis n'importe quel écran.
Leçon : paramètres et retour documentent la dépendance ; aucune variable globale cachée.
Vocabulaire de la section
- Procédure
- Bloc de code nommé et réutilisable, écrit une fois et appelé autant de fois que nécessaire.
Exemple simple : Yacine appelle CalculeMontantTTC depuis la fenêtre de commande et celle de facture.
Ce que ce n'est pas : du code recopié à l'identique dans trois événements différents.
Réflexe : duplication à supprimer → une procédure.
- Procédure globale
- Procédure déclarée au niveau du projet et accessible depuis tous les écrans et traitements.
Exemple simple : CalculeRemiseFidelite vit dans une collection globale.
Ce que ce n'est pas : une procédure déclarée dans une seule fenêtre et invisible ailleurs.
Réflexe : règle utilisée partout → procédure globale.
- Collection de procédures
- Élément du projet regroupant des procédures par thème pour organiser un projet qui grandit.
Exemple simple : GestionCommerciale rassemble les calculs de remise, de TVA et de port.
Ce que ce n'est pas : des procédures éparpillées sans regroupement thématique.
Réflexe : organiser par thème → une collection.
- Passage par valeur
- Transmission d'une copie du paramètre : la procédure ne modifie pas la variable d'origine.
Exemple simple : Yacine passe un montant à une procédure de calcul sans altérer la saisie.
Ce que ce n'est pas : une procédure qui met à jour directement la variable de l'appelant.
Réflexe : original intact → passage par valeur.
- Passage par référence
- Transmission de la variable elle-même : la procédure peut modifier la valeur d'origine.
Exemple simple : Yacine fait remplir un tableau de lignes par une procédure via une référence.
Ce que ce n'est pas : une copie locale perdue à la fin de la procédure.
Réflexe : modifier l'original → passage par référence.
En pratique — En pratique — Structurer son code en procédures
- Repérez un traitement copié-collé (ou sur le point de l'être) : c'est le signal qu'il doit devenir une procédure, comme pour Yacine.
- Créez une procédure globale si la règle sert dans plusieurs écrans, locale si elle ne concerne qu'une fenêtre.
- Donnez-lui des paramètres et une valeur de retour plutôt que de la faire dépendre de variables globales.
- Regroupez les procédures par thème dans des collections, avec des noms explicites décrivant ce qu'elles font.
Script pas-à-pas — factoriser comme Yacine (4 min)
1) Cherchez un calcul ou un contrôle recopié dans plusieurs écrans. 2) Décidez la portée : globale pour un usage transversal, locale pour un seul écran. 3) Écrivez la procédure avec ses paramètres et sa valeur de retour. 4) Rangez-la dans une collection thématique avec un nom explicite. 5) Remplacez les copies par des appels et vérifiez qu'aucune variable globale ne porte l'état.
Gardez ce réflexe : si vous vous apprêtez à copier-coller, arrêtez-vous et créez une procédure.
Modèle copier-coller — la fiche procédures de Yacine
Signal : duplication, longueur, complexite, besoin de tester
Portee : LOCALE (une fenetre) / GLOBALE (tout le projet)
Collection : regrouper par theme (commercial, dates, services)
Parametres : valeur (copie) / reference (modifie l'original)
Qualite : une responsabilite, un nom explicite, peu de globalesUne remise copiée trois fois
Yacine crée CalculeRemiseFidelite en procédure globale : une seule correction suffit désormais.
Un contrôle propre à un écran
Yacine garde ControleSaisieCommande en procédure locale à la fenêtre de commande.
Un total non mis à jour
Yacine croyait modifier l'original : il passe le paramètre par référence et corrige le bug.
Des procédures en désordre
Yacine regroupe calculs, dates et exports dans trois collections claires de la gestion.
✓ Bonnes pratiques
- Transformer tout copier-coller en procédure.
- Choisir la portée selon l'usage réel.
- Préférer paramètres et retours aux variables globales.
✗ Pièges fréquents
- Mettre une règle transversale dans une procédure locale.
- Confondre passage par valeur et par référence.
- Accumuler des variables globales modifiables partout.
Points clés à retenir
- Une procédure est un bloc nommé et réutilisable qui supprime la duplication.
- Locale (une fenêtre), globale (tout le projet) ou regroupée en collection par thème.
- Le passage par valeur copie ; le passage par référence modifie l'original.
- Une responsabilité par procédure, un nom explicite et peu de variables globales.
Défi 48h — appliquez demain
Comme Yacine, ouvrez votre application et repérez un calcul copié-collé dans au moins deux écrans. Transformez-le en procédure globale avec des paramètres et une valeur de retour, puis rangez-la dans une collection au nom explicite. Vérifiez enfin si vous avez besoin d'un passage par valeur ou par référence, et supprimez la variable globale devenue inutile.
- Je peux expliquer la différence entre procédure locale et globale.
- Je sais créer une collection de procédures par thème.
- Je distingue passage par valeur et passage par référence.
Questions fréquentes
Quand faut-il créer une procédure plutôt que d'écrire le code sur place ?
Dès que le code est utilisé plusieurs fois, qu'un traitement devient long ou qu'un bloc mérite un nom pour être compris. Le signal numéro un reste la duplication : si vous copiez-collez, ou si vous vous apprêtez à le faire, faites-en une procédure. Une règle métier — calcul de TVA, remise fidélité, contrôle d'un code — servira forcément ailleurs : écran, état, import ou service web.
Pourquoi faut-il limiter les variables globales ?
Parce qu'une variable globale peut être lue et modifiée de n'importe où, à n'importe quel moment : le code devient imprévisible et les bugs très difficiles à localiser. Une procédure qui dépend d'une globale cache cette dépendance dans sa signature. Préférez les paramètres et les valeurs de retour : la procédure devient réutilisable, testable et prévisible.
Quel signal impose de transformer un code en procédure ?