Scope (Portée lexicale des variables)

La portée lexicale (ou scope) est un concept fondamental en programmation qui définit l'espace dans lequel une variables |variables est accessible. En d'autres termes, c'est la région du code où une variable a une valeur.

Par exemple, si vous déclarez une variable x à l'intérieur d'une fonctions (programmation), cette variable sera disponible uniquement au sein de cette fonction et pas à l'extérieur. Cela signifie que si vous essayez d'accéder à la variable x à l'extérieur de la fonction, elle ne sera pas définie et vous obtiendrez une erreur.

Voici un exemple de code en TypeScript pour illustrer cela :

function maFonction() {
  let x = 5; // Déclaration de la variable x à l'intérieur de la fonction

  console.log(x); // Affichage de la valeur de x, qui vaut 5
}

maFonction();

// Essayons d'accéder à la variable x à l'extérieur de la fonction
console.log(x); // Erreur : x n'est pas définie à cet emplacement

Dans ce code, nous déclarons une variable x à l'intérieur de la fonction maFonction. Cette variable est accessible uniquement au sein de cette fonction et pas à l'extérieur. Si nous essayons d'accéder à la variable x à l'extérieur de la fonction, nous obtiendrons une erreur parce que x n'est plus définie.

La portée lexicale est donc un mécanisme qui permet de gérer les variables et leur accessibilité au sein du code. Elle est essentielle pour éviter les erreurs et les conflits entre les différentes parties du code.

Niveaux de scope

1. Variables globales : Si tu places quelque chose dans le salon (variable globale), tout le monde dans la maison peut l'utiliser sans problème. Dans un programme, une variable globale peut être utilisée n'importe où dans le code.

2. Variables locales : Mais si tu choisis de garder quelque chose dans ta chambre (variable locale), seulement toi (ou la fonction où tu l'as mise) peut l'utiliser. En dehors de ta chambre, personne ne sait que ça existe. Dans un programme, une variable locale ne peut être utilisée que dans la fonction ou le bloc où elle a été déclarée.

3. Scope : Allons un peu plus loin, si tu as un coffre dans ta chambre et que tu y mets certaines choses, ces choses sont encore plus privées. Elles sont accessibles dans ta chambre (dans le bloc de code) mais uniquement quand le coffre est ouvert (quand le bloc de code s'exécute).

Exemple simple :

x = 5 # Variable globale

def ma_fonction():
    y = 10 # Variable locale à ma_fonction
    print(x) # Ça marche, x est globale
    print(y) # Ça marche, y est dans la même "pièce" (fonction)

# print(y) ça ne marcherait pas ici, y n'est pas connue en dehors de ma_fonction

ma_fonction()

Notions à explorer pour aller plus loin :

• Durée de vie d'une variable : Comprendre combien de temps une variable reste en mémoire.
• closure (JavaScript) : Fonctions qui se souviennent des variables de l'espace où elles ont été créées, même après que cet espace n'existe plus.
• Variables d'instance et de classe : Dans la programmation orientée objet, comprendre comment les variables sont liées aux objets ou aux classes.
• Namespaces : Un système pour s'assurer que tous les noms dans un programme sont uniques et ne créent pas de conflit.
• Lexical scoping : La façon dont le langage de programmation résout les identifiants (noms de variables) en fonction de leur portée lexicale.
• Scope chain : La chaîne de scopes qui permet à une variable d'être accessible depuis différents niveaux de la hiérarchie de scopes.
• Hoisting : Le mécanisme qui fait monter les déclarations de variables et de fonctions au début du scope où elles sont définies.
• Block scoping : La façon dont les blocs de code (par exemple, des boucles ou des structures conditionnelles) ont leur propre scope.
• Function scoping : La façon dont les fonctions ont leur propre scope et comment il est possible d'accéder aux variables définies à l'intérieur d'une fonction depuis l'extérieur.