Les types et portées des variables¶

1. Objectif du cours¶

Comprendre les différences entre langages typés et non typés, ainsi que les concepts de portée des variables (locale, globale, supervariable). Savoir appliquer ces notions en pseudocode et repérer les conséquences sur la conception, la maintenance et les performances.

2. Notions et définitions essentielles¶

Langage typé : le type de chaque variable est déclaré explicitement (ex. Java, C++, C#).
Langage non typé / typage dynamique : le type est déterminé automatiquement selon la valeur (ex. JavaScript, Python, PHP).
Portée (scope) : zone du code où une variable est accessible. Principales portée : locale, globale, et notion de supervariable (portée étendue).
Variable locale : déclarée à l'intérieur d'une fonction/ d'un bloc ; accessible uniquement là.
Variable globale : déclarée en dehors des fonctions ; accessible dans tout le programme.
Supervariable : variable avec portée étendue (ex. attribut de classe accessible aux instances et classes dérivées).

3. Fonctionnement et principes¶

Le typage influe sur la détection d'erreurs : typage statique permet de détecter les erreurs à la compilation ; typage dynamique peut masquer des erreurs par conversions automatiques à l'exécution.
Impact sur la conception : typage statique favorise la sûreté, la lisibilité et l'optimisation ; typage dynamique favorise la flexibilité et la concision.
Portée et structure : dans les langages à blocs (C, C++, Java), la portée peut être très granulaire (blocs imbriqués). Dans les langages sans blocs (Python), la portée se limite souvent au niveau des fonctions/modules.
Bonnes pratiques structurelles : limiter la portée des variables (déclarer près de l'utilisation), préférer le passage de paramètres plutôt que des globals, nommer clairement pour éviter les conflits.

4. Commandes et manipulations¶

Regroupe les éléments syntaxiques et constructions réellement présentes dans le document (pseudocode, Python, C#).

Pseudocode — délimitation et déclarations :
DEBUT / FIN : début et fin d'un bloc pseudocode.
ENTIER, FLOTTANT/REEL, CHAINE, BOOLEEN : mots-clés de type en pseudocode.
Fonction nom(...) -> Type : définition de fonction avec signature (paramètres et type de retour).
Retourner : renvoyer une valeur d'une fonction.
<- ou = : affectation d'une valeur à une variable.
Pour chaque / Pour : itération sur un ensemble.
// : commentaire en ligne.
Pseudocode — opérations et conversions :
(REEL)somme : conversion de type explicite (cast) en exemple pseudocode.
Python (extrait) — accès et affichage :
Déclaration globale au module : global_var = "..." (affectation au niveau module).
def ma_fonction(): / local_var = ... : définition de fonction et variable locale.
print(...) : affichage/verification d'accès à variable.
appel de fonction : ma_fonction().
C# (extrait) — déclaration et écriture console :
static string globalVar = "..." : variable de classe (portée globale dans l'exemple).
static void MaFonction() / string localVar = "..." : fonction et variable locale.
Console.WriteLine(...) : affichage.
static void Main(string[] args) : point d'entrée.

(NB : le document présente des extraits simples ; il ne propose pas de scripts longs à recopier.)

5. Sécurité et bonnes pratiques¶

Précautions et recommandations explicitement abordées dans le document : - Privilégier les variables locales pour limiter les effets de bord et optimiser la mémoire.
- Minimiser l'usage des variables globales et de supervariables sauf nécessité (configurations, constantes).
- Limiter la portée des variables au strict nécessaire (déclarer près de l'utilisation).
- Utiliser des noms clairs et descriptifs pour éviter la confusion et les conflits de noms.
- Préférer le passage de paramètres entre fonctions plutôt que le partage via globals.
- Tenir compte des spécificités du langage utilisé (comportement de la division, conversions implicites, portée par module vs par bloc).

6. Points essentiels à retenir pour le TSSR¶

Distinction claire : typage statique (déclaratif, compilation) vs typage dynamique (déduit à l'exécution).
Les langages typés offrent meilleure sûreté et parfois de meilleures performances ; les non typés offrent flexibilité et concision.
Variable locale = accessible seulement dans la fonction/bloc ; variable globale = accessible partout.
Les supervariables (ex. variables de classe) ont une portée étendue et doivent être utilisées avec parcimonie.
Dans les langages à blocs, la portée peut être limitée à des blocs imbriqués ; dans d'autres, elle est souvent au niveau du module.
Les conversions automatiques en langages dynamiques peuvent masquer des erreurs et produire des comportements inattendus.
Nommer distinctement les variables globale/locales (éviter les homonymes) pour réduire la confusion.
Vérifier le comportement des opérations sensibles (ex. division entière vs flottante) selon le langage ciblé.
Préférer le passage de paramètres pour partager des données entre fonctions.
Les annotations/types optionnels (ex. TypeScript, annotations Python) permettent un compromis entre sûreté et flexibilité.

7. Tableau récapitulatif¶

Notion	Typé statique	Typé dynamique
Détection d'erreurs	Compilation (précoce)	À l'exécution (potentiellement masquée)
Flexibilité	Moins flexible	Très flexible
Performance	Souvent meilleure	Possible surcharge liée aux vérifs/convert.
Exemple cité	Java, C++, C#	JavaScript, Python, PHP

8. Vérifications pratiques¶

Vérifications concrètes présentées dans le cours pour constater le bon fonctionnement : - Afficher une variable locale dans la fonction puis tenter d'y accéder en dehors : provoque une erreur (local_var dans l'exemple Python/C#).
- Afficher une variable globale depuis la fonction et depuis l'extérieur : accessibilité confirmée (global_var).
- Concaténation de chaînes : vérifier que le résultat est une chaîne (resultat = s1 + s2).
- Division : vérifier le type/valeur du résultat selon langage (en C# division d'int/int peut donner int ; en Python / donne float).
- Variables homonymes (globale vs locale) : vérifier qu'elles sont indépendantes (ex. deux y distinctes produisent valeurs séparées).

9. Flashcards Anki¶

Qu'est-ce qu'une variable locale ? :: Variable déclarée à l'intérieur d'une fonction ou d'un bloc et accessible uniquement dans cette portion de code. Qu'est-ce qu'une variable globale ? :: Variable déclarée en dehors de toute fonction et accessible dans l'ensemble du programme. Donnez un exemple de langage typé cité dans le document. :: Java (également C++ ou C#). Donnez un exemple de langage non typé cité dans le document. :: Python (également JavaScript ou PHP). Que signifie typage statique selon le document ? :: Le programmeur précise les types à la déclaration et les erreurs de typage sont détectées à la compilation. Que signifie typage dynamique selon le document ? :: Les types sont déterminés automatiquement d'après les valeurs et les vérifications ont lieu à l'exécution. Pourquoi privilégier les variables locales ? :: Elles limitent l'accès aux données, réduisent les erreurs et optimisent la gestion mémoire. Que sont les supervariables dans ce document ? :: Variables à portée étendue à plusieurs niveaux, par exemple variables de classe accessibles par toutes les instances. Quel risque apportent les conversions automatiques dans les langages non typés ? :: Elles peuvent masquer des erreurs de typage et produire des résultats inattendus. Que montre l'exemple Python/C# avec local_var et global_var ? :: Que la variable locale est accessible dans la fonction mais non en dehors, tandis que la variable globale l'est partout.