Scheda di revisione: 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

Élément	Caractéristiques clés	Notes / Différences
Sous-programme	Fonction ou procédure, avec paramètres et espace de noms	Fonction retourne une valeur, proc non
Portée	Locale (dans sous-programme ou bloc) ou globale	Définie par lieu de déclaration
Variables locales	Déclarées dans le sous-programme, visibles uniquement dedans	Limité au contexte du sous-programme
Variables globales	Déclarées hors sous-programme, accessibles partout	Risque de conflits ou effets de bord
Passage par valeur	Copie la donnée, modifications non visibles à l’extérieur	Sécurité accrue, moins flexible
Passage par référence	Utilise l’adresse mémoire, modifications visibles	Plus efficace pour gros objets
Espaces de noms	Définis par lieu de déclaration, évitent conflits	Clé pour modularité
Exemple somme n premiers	Boucle for additionne de 1 à n, retourne la somme	Fonction paramétrée par limite

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.

---