Aller au contenu
Encyclopédie informatique Édition 2026

Variables et types de données

Partie 2 sur 5

Niveau de lecture :

4La portée des variables

Selon l’endroit où l’on déclare une variable, celle-ci pourra être accessible (visible) de partout dans le code, ou seulement dans une portion confinée de celui-ci (à l’intérieur d’une fonction par exemple). On parle de portée (ou visibilité) d’une variable. La figure 2 en montre le principe.

LA PORTÉE : OÙ UNE VARIABLE EST VISIBLE programme entier — variable globale : total fonction A — locale : compteur boucle dans A — locale : i voit i, compteur et total fonction B — locale : compteur voit son compteur (un autre !) et total, mais pas celui de A ni le i de la boucle Règle : un bloc voit ce qui l’entoure, jamais ce qui est à l’intérieur d’un autre.
Figure 2. La portée : un bloc voit ce qui l’entoure, jamais l’intérieur d’un autre bloc.

4.1Variables globales et locales

Lorsqu’une variable est déclarée dans le code même, c’est-à-dire à l’extérieur de toute fonction ou de tout bloc d’instructions, elle est accessible de partout dans le code : n’importe quelle fonction du programme peut faire appel à cette variable. On parle alors de variable globale. Lorsque l’on déclare une variable à l’intérieur d’un bloc d’instructions (entre des accolades), sa portée se confine à l’intérieur du bloc dans lequel elle est déclarée : elle est inutilisable ailleurs. On parle alors de variable locale. Une variable déclarée au début du code, avant tout bloc, sera donc globale, alors qu’une variable déclarée dans une fonction ou une boucle aura une portée limitée à ce seul bloc d’instructions.

La variable locale a aussi une durée de vie limitée : elle naît quand on entre dans le bloc et disparaît quand on en sort. Sa place en mémoire est alors rendue au système, et peut être réutilisée. Une variable globale, elle, existe aussi longtemps que le programme.

4.2Le masquage

Que se passe-t-il si deux variables portent le même nom dans des blocs différents ? Un exemple en C++ le montre : une variable globale i valant 3, et dans la fonction principale une variable locale i valant 12. À l’intérieur de la fonction, le nom i désigne la locale : elle masque la globale. Pour atteindre la globale malgré tout, le C++ propose l’opérateur de résolution de portée, noté ::. L’instruction ::i = i + ::i; ajoute à la variable globale (celle située en dehors de la fonction) la valeur de la variable locale : ici, la globale passerait de 3 à 12 + 3 = 15. Cette gymnastique est la preuve que le masquage est un piège ; il est d’ailleurs préférable de donner des noms différents aux variables locales et globales. Cette règle de prudence vaut dans tous les langages.

4.3Un exemple JavaScript qui a fait date

Un exemple instructif en JavaScript peut se raconter sans code. Une variable a vaut 12 au début du script. Une fonction calcule le double de son paramètre. Dans une première version, la fonction déclare sa propre variable a avec le mot clé var : à la fin, l’affichage donne « le double de 4 est 8 » puis « la valeur de a est 12 », car la a de la fonction était locale et n’a pas touché à la globale. Dans une seconde version, la fonction écrit simplement a = b * 2 sans var : il n’y a pas de déclaration, donc l’affectation modifie la variable globale existante, et le script affiche « la valeur de a est 8 » : la variable globale a été écrasée par accident. La leçon : il faut déclarer systématiquement les nouvelles variables avec le mot clé var. C’est toujours vrai, avec let et const aujourd’hui.

Un mot sur la portée du var : il était limité à la fonction, non au bloc, ce qui surprenait (une variable déclarée dans une boucle restait visible après la boucle). let et const corrigent cela : ils respectent les blocs, comme en C et en Java. Python, de son côté, n’a pas de blocs pour les boucles et les conditions : une variable créée dans une boucle reste visible après.

4.4Pourquoi limiter la portée

La règle d’or est de donner à chaque variable la portée la plus petite possible. Une variable globale peut être modifiée par n’importe quelle partie du programme : en cas de valeur surprenante, il faut chercher partout qui l’a changée. Une variable locale n’est modifiée que dans son bloc, ce qui rend le comportement du programme prévisible et testable. Les globales sont néanmoins utiles pour des réglages partagés (un fichier de configuration) ou des constantes ; on les limite alors aux valeurs qui ne changent pas. Dans un programme concurrent (plusieurs tâches simultanées), les globales modifiables sont une source classique de bogues rares et difficiles à reproduire (voir les processus).

Pour s’exercer

Exercice 3 : suivre la portée

Une variable globale a vaut 12. Une fonction reçoit b = 4 et déclare a = b * 2 sans déclaration locale (en JavaScript sans var). Que vaut a après l’appel ? Et si la fonction avait déclaré var a ?

Voir la réponse

Sans déclaration, l’affectation modifie la variable globale : a vaut 8. Avec var a, la fonction crée sa propre variable locale : la globale reste à 12. La leçon : déclarer toujours les variables avec var (aujourd’hui let ou const) pour ne pas écraser une globale par accident.

5Les constantes

Une constante est une variable dont la valeur est inchangeable lors de l’exécution d’un programme. Le nombre pi, le taux de TVA, le nombre de jours d’une semaine : ces valeurs ne devraient jamais changer par accident. Les déclarer comme constantes protège le programme (le compilateur refuse toute modification) et le rend plus lisible (on écrit TAUX_TVA plutôt qu’un « 0,2 » mystérieux, appelé en jargon un nombre magique). Chaque langage a sa façon d’en définir.

5.1En C : #define et const

En langage C, les constantes sont définies, à l’origine, grâce à la directive du préprocesseur #define. Le préprocesseur est un outil qui traite le texte du programme avant la compilation. La directive remplace toutes les occurrences du mot qui la suit par la valeur placée juste derrière. Avec #define _Pi 3.1415927, tous les identifiants _Pi sont remplacés par 3.1415927 : dans resultat = _Pi * sin(a);, dans resultat = _Pi + 1; ; même dans _Pi = 12;, qui est remplacé mais génère alors une erreur (on ne peut affecter une valeur à un nombre) ; mais pas dans resultat = _PiPo; (autre mot) ni dans la chaîne de caractères printf("pi = _Pi ");. Le défaut de cette méthode est que les constantes ne sont pas typées, et que le #define fait du « chercher-remplacer » textuel sans réfléchir : il faut donc l’utiliser avec parcimonie. Il est préférable d’utiliser le mot clé const, qui permet de déclarer des constantes typées : const int dix = 10;. Le C++ a fait du const la méthode normale (const int A = 26;), qui doit être initialisée dès sa définition.

5.2En Java : final

Java ne possède pas véritablement de constantes. Le mot clé final permet toutefois de définir une variable dont la valeur ne peut pas être modifiée après son initialisation : final int Variable = 12; définit un entier valant 12 et que le compilateur refusera de changer dans la suite du code. Il s’agit d’une utilisation restrictive du mot clé : final permet aussi d’affecter une valeur différente à chaque exécution du programme (par exemple une valeur lue au démarrage), tout en garantissant que la variable, une fois initialisée, ne subira plus aucune modification. Une constante au sens strict, valable pour tout le programme, se déclare avec static final et un nom en majuscules.

5.3En PHP : define()

Avec PHP, les constantes sont définies grâce à la fonction define() : define("Nom_de_la_variable", Valeur);. Le nom d’une constante définie ainsi ne doit pas commencer par le caractère $, de sorte qu’aucune affectation n’est possible (le signe dollar est justement ce qui marque une variable). Le PHP moderne offre aussi le mot const.

5.4Ce qu’il faut retenir, et les langages récents

Dans tous les cas, une constante porte un nom explicite, souvent en majuscules (TAUX_TVA), et est définie à un seul endroit : si le taux change, on le modifie une fois. Les langages récents poussent plus loin cette idée : en JavaScript, const interdit de réaffecter la variable ; en Kotlin et Swift, val et let déclarent des valeurs non modifiables et sont recommandés par défaut (voir Kotlin et Swift) ; en Rust, les variables sont immuables par défaut et il faut écrire mut pour pouvoir les modifier (voir Rust). L’idée générale est que tout ce qui n’a pas besoin de changer ne devrait pas pouvoir changer. Attention enfin à une nuance : const en JavaScript empêche de remplacer la variable, mais ne rend pas ses éléments immuables si elle désigne un tableau ou un objet.