Fiche de révision : Maîtrise des sous-programmes en Go

📌 L'essentiel

• Sous-programmes : fonctions ou procédures, avec leur propre espace de noms.
• Portée des variables : locale (dans sous-programme ou bloc) ou globale.
• Paramètres : passés par valeur (copie) ou par référence (adresse).
• Variables locales : visibles uniquement dans leur sous-programme.
• Variables globales : accessibles dans tout le programme.
• Fonctions : retournent une valeur, peuvent avoir plusieurs paramètres.
• Procédures : n'ont pas de valeur de retour.
• Exemples courants : saisie avec vérification, somme des n premiers, minimum de deux nombres.
• Gestion des espaces de noms : évite conflits d’identificateurs.
• Organisation hiérarchique : sous-programme → appel → exécution.

2. 🧩 Structures & Composants clés

• Sous-programme (fonction/procédure) — encapsule un bloc d’instructions, avec paramètres et espace de noms.
• Variables locales — déclarées dans le sous-programme, visibles uniquement dans celui-ci.
• Variables globales — déclarées hors sous-programme, accessibles partout.
• Paramètres — variables d’entrée, passés par valeur ou référence.
• Espaces de noms — zones de visibilité, évitent conflits.
• Passage par valeur — copie la donnée, modifications non visibles à l’extérieur.
• Passage par référence — modifie directement la variable d’origine.
• Exemples : demanderNote, sommeNPremiers, minimum.
• Gestion de la portée — dépend du lieu de déclaration.

3. 🔬 Fonctions, Mécanismes & Relations

• Définition d’une fonction : func nomFonction(params) returnType { ... }
• Appel d’une fonction : transmet des arguments, récupère la valeur retournée.
• Vérification dans une saisie : boucle while ou for pour valider la valeur.
• Calcul de somme : boucle for additionne de 1 à n.
• Calcul du minimum : condition if pour comparer deux valeurs.
• Passage par valeur : copie la donnée, modifications internes non visibles.
• Passage par référence : utilise l’adresse mémoire, modifications visibles.
• Organisation :
  • Variables globales accessibles partout.
  • Variables locales limitées au sous-programme ou bloc.
  • Espaces de noms évitent conflits.
• Flux d’exécution :

  Appel de la fonction
       │
       ▼
  Exécution dans le sous-programme
       │
       ▼
  Retour à l’appelant avec résultat (si fonction)
  

4. Tableau synthèse

5. Diagramme hiérarchique ASCII

Sous-programme
 ├─ Déclaration
 │    ├─ Paramètres (passage par valeur ou référence)
 │    └─ Variables locales
 ├─ Appel
 │    └─ Passage d'arguments
 └─ Retour

6. ⚠️ Pièges & Confusions fréquentes

• Confondre variables locales et globales.
• Oublier que la portée d’une variable locale est limitée au sous-programme.
• Confondre passage par valeur et par référence.
• Utiliser une variable globale sans précaution.
• Ne pas vérifier la validité d’une entrée utilisateur.
• Oublier que les paramètres sont invisibles en dehors du sous-programme.
• Confondre fonction (avec retour) et procédure (sans retour).
• Ignorer l’importance de l’espace de noms pour éviter conflits.
• Modifier une variable globale dans une fonction sans précaution.
• Ne pas respecter la hiérarchie d’appels et de flux.

7. ✅ Checklist Examen Final

• Définir une fonction et une procédure en Go.
• Expliquer la différence entre variables locales et globales.
• Décrire le passage par valeur et par référence.
• Illustrer la gestion des espaces de noms.
• Écrire une fonction de calcul de somme ou minimum.
• Expliquer la portée d’une variable selon son lieu de déclaration.
• Décrire le flux d’un appel de sous-programme.
• Identifier les pièges courants liés à la portée.
• Savoir vérifier une saisie utilisateur.
• Expliquer l’intérêt des sous-programmes pour la modularité.
• Définir une variable locale dans un bloc.
• Illustrer un exemple de passage par référence.
• Savoir utiliser une fonction pour retourner une valeur.
• Connaître la syntaxe de déclaration d’une fonction en Go.
• Expliquer comment éviter les conflits d’identificateurs.
• Comprendre l’impact de la portée sur la sécurité du code.

---