Variable (informatique)

En programmation informatique , une variable est un emplacement de stockage abstrait associé à un nom symbolique associé , qui contient une quantité connue ou inconnue de données ou d'objets appelés valeur ; ou en termes plus simples, une variable est un conteneur nommé pour un ensemble particulier de bits ou un type de données (comme un entier , un flottant , une chaîne , etc.). Une variable peut éventuellement être associée ou identifiée par une adresse mémoire . Le nom de la variable est le moyen habituel de référencer la valeur stockée, en plus de faire référence à la variable elle-même, selon le contexte. Cette séparation du nom et du contenu permet d'utiliser le nom indépendamment des informations exactes qu'il représente. L'identifiant dans le code source de l'ordinateur peut être lié à une valeur pendant l'exécution , et la valeur de la variable peut ainsi changer au cours de l'exécution du programme .

Les variables en programmation ne correspondent pas forcément directement au concept de variables en mathématiques . Ce dernier est abstrait , n'ayant aucune référence à un objet physique tel qu'un lieu de stockage. La valeur d'une variable informatique ne fait pas nécessairement partie d'une équation ou d'une formule comme en mathématiques. Les variables en programmation informatique portent souvent des noms longs pour les rendre relativement descriptifs de leur utilisation, alors que les variables en mathématiques ont souvent des noms concis, à un ou deux caractères, pour une transcription et une manipulation plus concise.

L'emplacement de stockage d'une variable peut être référencé par plusieurs identifiants différents, une situation connue sous le nom d'aliasing . L'attribution d'une valeur à la variable à l'aide de l'un des identifiants modifiera la valeur accessible via les autres identifiants.

Les compilateurs doivent remplacer les noms symboliques des variables par les emplacements réels des données. Bien que le nom, le type et l'emplacement d'une variable restent souvent fixes, les données stockées à cet emplacement peuvent être modifiées pendant l'exécution du programme.

Dans les langages de programmation impératifs , les valeurs peuvent généralement être consultées ou modifiées à tout moment. Dans les langages purement fonctionnels et logiques , les variables sont liées à des expressions et conservent une valeur unique pendant toute leur durée de vie en raison des exigences de transparence référentielle . Dans les langages impératifs, le même comportement est observé pour les constantes (nommées) (constantes symboliques), qui sont généralement contrastées avec les variables (normales).

Selon le système de types d'un langage de programmation, les variables peuvent uniquement être en mesure de stocker un type de données spécifié (par exemple, un entier ou une chaîne ). Alternativement, un type de données peut être associé uniquement à la valeur actuelle, ce qui permet à une seule variable de stocker tout ce qui est pris en charge par le langage de programmation. Les variables sont les conteneurs pour stocker les valeurs.

Variables et portée :

• Variables automatiques : Chaque variable locale d'une fonction n'apparaît que lorsque la fonction est appelée et disparaît lorsque la fonction est quittée. Ces variables sont appelées variables automatiques.
• Variables externes : il s'agit de variables externes à une fonction et auxquelles n'importe quelle fonction peut accéder par son nom. Ces variables existent en permanence ; au lieu d'apparaître et de disparaître lorsque des fonctions sont appelées et quittées, elles conservent leurs valeurs même après le retour des fonctions qui les ont définies.

Un identifiant référençant une variable peut être utilisé pour accéder à la variable afin de lire la valeur, ou de modifier la valeur, ou de modifier d'autres attributs de la variable, tels que l'autorisation d'accès, les verrous , les sémaphores , etc.

Par exemple, une variable peut être référencée par l'identifiant «total_count » et la variable peut contenir le nombre 1956. Si la même variable est régalement référencée par l'identifiant « » et si vous utilisez cet identifiant «r », la valeur de la variable est modifiée en 2009, alors la lecture de la valeur à l'aide de l'identifiant «total_count » donnera un résultat de 2009 et non de 1956.

Si une variable n'est référencée que par un seul identifiant, cet identifiant peut être simplement appelé le nom de la variable ; sinon, on peut en parler comme d'un des noms de la variable . Par exemple, dans l'exemple précédent, l'identifiant " total_count" est le nom de la variable en question, et " r" est un autre nom de la même variable.

La portée d'une variable décrit où dans le texte d'un programme la variable peut être utilisée, tandis que l' étendue (également appelée durée de vie ) d'une variable décrit à quel moment dans l'exécution d'un programme la variable a une valeur (significative). La portée d'une variable affecte son étendue. La portée d'une variable est en fait une propriété du nom de la variable, et l'étendue est une propriété de l'emplacement de stockage de la variable. Ces éléments ne doivent pas être confondus avec le contexte (également appelé environnement ), qui est une propriété du programme, et varie selon le point dans le texte ou l'exécution du programme (voir portée : aperçu) . De plus, la durée de vie d'un objet peut coïncider avec la durée de vie d'une variable, mais dans de nombreux cas, elle n'y est pas liée.

La portée est une partie importante de la résolution du nom d'une variable. La plupart des langages définissent une portée spécifique pour chaque variable (ainsi que pour toute autre entité nommée), qui peut différer au sein d'un programme donné. La portée d'une variable est la partie du texte du programme pour laquelle le nom de la variable a une signification et pour laquelle la variable est dite « visible ». L'entrée dans cette portée commence généralement la durée de vie d'une variable (lorsqu'elle entre dans le contexte) et la sortie de cette portée termine généralement sa durée de vie (lorsqu'elle sort du contexte). Par exemple, une variable avec une « portée lexicale » n'a de sens que dans une certaine fonction/ sous-routine , ou plus précisément dans un bloc d'expressions/instructions (conformément à la portée de fonction ou à la portée de bloc ) ; il s'agit d'une résolution statique, réalisable au moment de l'analyse ou de la compilation. Alternativement, une variable avec une portée dynamique est résolue au moment de l'exécution, sur la base d'une pile de liaison globale qui dépend du flux de contrôle spécifique . Les variables accessibles uniquement dans certaines fonctions sont appelées « variables locales ». Une « variable globale », ou une variable à portée indéfinie, peut être référencée n'importe où dans le programme.

L'étendue , en revanche, est un aspect d'exécution ( dynamique ) d'une variable. Chaque liaison d'une variable à une valeur peut avoir sa propre étendue au moment de l'exécution. L'étendue de la liaison est la partie du temps d'exécution du programme pendant laquelle la variable continue de faire référence à la même valeur ou au même emplacement mémoire. Un programme en cours d'exécution peut entrer et sortir d'une étendue donnée plusieurs fois, comme dans le cas d'une fermeture .

À moins que le langage de programmation ne dispose d'un ramasse-miettes , une variable dont l'étendue dépasse définitivement sa portée peut entraîner une fuite de mémoire , par laquelle la mémoire allouée à la variable ne peut jamais être libérée puisque la variable qui serait utilisée pour la référencer à des fins de désallocation n'est plus accessible. Cependant, il peut être permis qu'une liaison de variable s'étende au-delà de sa portée, comme cela se produit dans les fermetures Lisp et les variables locales statiques C ; lorsque l'exécution repasse dans la portée de la variable, la variable peut à nouveau être utilisée. Une variable dont la portée commence avant son étendue est dite non initialisée et a souvent une valeur indéfinie et arbitraire si elle est consultée (voir wild pointer ), car elle n'a pas encore reçu explicitement de valeur particulière. Une variable dont l'étendue se termine avant sa portée peut devenir un pointeur suspendu et être considérée à nouveau non initialisée puisque sa valeur a été détruite. Les variables décrites par les deux cas précédents peuvent être dites hors étendue ou non liées . Dans de nombreux langages, c'est une erreur d'essayer d'utiliser la valeur d'une variable lorsqu'elle est hors étendue. Dans d'autres langages, cela peut donner des résultats imprévisibles . Une telle variable peut cependant se voir attribuer une nouvelle valeur, ce qui lui donne une nouvelle étendue.

Pour une utilisation plus efficace de l'espace, l'espace mémoire nécessaire à une variable peut être alloué uniquement lorsque la variable est utilisée pour la première fois et libéré lorsqu'elle n'est plus nécessaire. Une variable n'est nécessaire que lorsqu'elle est dans la portée, donc le fait de commencer la durée de vie de chaque variable lorsqu'elle entre dans la portée peut donner de l'espace aux variables inutilisées. Pour éviter de gaspiller cet espace, les compilateurs avertissent souvent les programmeurs si une variable est déclarée mais non utilisée.

Il est considéré comme une bonne pratique de programmation de restreindre autant que possible la portée des variables afin que les différentes parties d'un programme n'interagissent pas accidentellement les unes avec les autres en modifiant les variables des autres. Cela permet également d'éviter toute action à distance . Les techniques courantes pour y parvenir consistent à faire en sorte que différentes sections d'un programme utilisent des espaces de noms différents ou à rendre des variables individuelles « privées » via une portée de variable dynamique ou une portée de variable lexicale .

De nombreux langages de programmation utilisent une valeur réservée (souvent nommée null ou nil ) pour indiquer une variable non valide ou non initialisée.

Dans les langages typés statiquement tels que C , C++ , Java ou C# , une variable possède également un type , ce qui signifie que seuls certains types de valeurs peuvent y être stockés. Par exemple, une variable de type « entier » ne peut pas stocker de valeurs textuelles.

Dans les langages typés dynamiquement tels que Python , le type d'une variable est déduit de sa valeur et peut changer en fonction de sa valeur. En Common Lisp , les deux situations existent simultanément : une variable reçoit un type (s'il n'est pas déclaré, il est supposé être , le supertypeT universel ) qui existe au moment de la compilation. Les valeurs ont également des types, qui peuvent être vérifiés et interrogés au moment de l'exécution.

Le typage des variables permet également de résoudre les polymorphismes au moment de la compilation. Cependant, cela diffère du polymorphisme utilisé dans les appels de fonctions orientées objet (appelés fonctions virtuelles en C++ ) qui résout l'appel en fonction du type de valeur plutôt que des supertypes que la variable est autorisée à avoir.

Les variables stockent souvent des données simples, comme des entiers et des chaînes littérales, mais certains langages de programmation permettent également à une variable de stocker des valeurs d'autres types de données . Ces langages peuvent également permettre aux fonctions d'être paramétriques polymorphes . Ces fonctions fonctionnent comme des variables pour représenter des données de plusieurs types. Par exemple, une fonction nommée lengthpeut déterminer la longueur d'une liste. Une telle lengthfonction peut être paramétrique polymorphe en incluant une variable de type dans sa signature de type , car le nombre d'éléments de la liste est indépendant des types des éléments.

Les paramètres formels (ou arguments formels ) des fonctions sont également appelés variables. Par exemple, dans ce segment de code Python ,

>>> def 
addtwo ( x ): 
... 
return 
x 
+ 
2 
... 
>>> addtwo ( 5 ) 
7

la variable nommée xest un paramètre car elle reçoit une valeur lorsque la fonction est appelée. L'entier 5 est l' argument qui donne xsa valeur. Dans la plupart des langages, les paramètres de fonction ont une portée locale. Cette variable spécifique nommée xne peut être référencée qu'à l'intérieur de la addtwofonction (bien que d'autres fonctions puissent également avoir des variables appelées x).

Les spécificités de l'allocation de variables et la représentation de leurs valeurs varient considérablement, à la fois entre les langages de programmation et entre les implémentations d'un langage donné. De nombreuses implémentations de langage allouent de l'espace aux variables locales , dont l'étendue dure le temps d'un seul appel de fonction sur la pile d'appels , et dont la mémoire est automatiquement récupérée lorsque la fonction revient. Plus généralement, dans la liaison de nom , le nom d'une variable est lié à l'adresse d'un bloc particulier (séquence contiguë) d'octets en mémoire, et les opérations sur la variable manipulent ce bloc. Le référencement est plus courant pour les variables dont les valeurs ont des tailles importantes ou inconnues lorsque le code est compilé. De telles variables référencent l'emplacement de la valeur au lieu de stocker la valeur elle-même, qui est allouée à partir d'un pool de mémoire appelé le tas .

Les variables liées ont des valeurs. Une valeur, cependant, est une abstraction, une idée ; dans l'implémentation, une valeur est représentée par un objet de données , qui est stocké quelque part dans la mémoire de l'ordinateur. Le programme, ou l' environnement d'exécution , doit réserver de la mémoire pour chaque objet de données et, comme la mémoire est limitée, s'assurer que cette mémoire est cédée pour être réutilisée lorsque l'objet n'est plus nécessaire pour représenter la valeur d'une variable.

Les objets alloués à partir du tas doivent être récupérés, en particulier lorsque les objets ne sont plus nécessaires. Dans un langage avec récupération de mémoire (tel que C# , Java , Python, Golang et Lisp ), l'environnement d'exécution récupère automatiquement les objets lorsque les variables existantes ne peuvent plus y faire référence. Dans les langages sans récupération de mémoire, tels que C , le programme (et le programmeur) doit allouer explicitement de la mémoire, puis la libérer ultérieurement, pour récupérer sa mémoire. Le non-respect de cette obligation entraîne des fuites de mémoire , dans lesquelles le tas est épuisé au fur et à mesure de l'exécution du programme, ce qui risque d'entraîner une défaillance éventuelle due à l'épuisement de la mémoire disponible.

Lorsqu'une variable fait référence à une structure de données créée dynamiquement, certains de ses composants ne peuvent être accessibles qu'indirectement via la variable. Dans de telles circonstances, les récupérateurs de mémoire (ou des fonctionnalités de programme analogues dans les langages qui n'en ont pas) doivent gérer un cas où seule une partie de la mémoire accessible à partir de la variable doit être récupérée.

Contrairement à leurs homologues mathématiques, les variables et constantes de programmation prennent généralement des noms à plusieurs caractères, par exemple COSTou total. Les noms à un seul caractère sont le plus souvent utilisés uniquement pour les variables auxiliaires ; par exemple, i, j, kpour les variables d'index de tableau .

Certaines conventions de dénomination sont appliquées au niveau du langage dans le cadre de la syntaxe du langage qui implique le format des identifiants valides. Dans presque tous les langages, les noms de variables ne peuvent pas commencer par un chiffre (0 à 9) et ne peuvent pas contenir de caractères d'espacement. L'autorisation ou non des signes de ponctuation dans les noms de variables varie d'une langue à l'autre ; de nombreux langages n'autorisent que le trait de soulignement (« _ ») dans les noms de variables et interdisent toute autre ponctuation. Dans certains langages de programmation, des sigils (symboles ou signes de ponctuation) sont apposés sur les identifiants de variables pour indiquer le type de données ou la portée de la variable.

La sensibilité à la casse des noms de variables varie également selon les langues et certaines langues exigent l'utilisation d'une certaine casse pour nommer certaines entités ; La plupart des langues modernes sont sensibles à la casse ; certaines langues plus anciennes ne le sont pas. Certaines langues réservent certaines formes de noms de variables à leur propre usage interne ; dans de nombreuses langues, les noms commençant par deux traits de soulignement (« __ ») relèvent souvent de cette catégorie.

Cependant, au-delà des restrictions de base imposées par un langage, la dénomination des variables est en grande partie une question de style. Au niveau du code machine , les noms de variables ne sont pas utilisés, de sorte que les noms exacts choisis n'ont pas d'importance pour l'ordinateur. Ainsi, les noms de variables les identifient, pour le reste, ils ne sont qu'un outil permettant aux programmeurs de rendre les programmes plus faciles à écrire et à comprendre. L'utilisation de noms de variables mal choisis peut rendre le code plus difficile à réviser que des noms non descriptifs, c'est pourquoi des noms clairs sont souvent encouragés.

Les programmeurs créent et respectent souvent des directives de style de code qui offrent des conseils sur la dénomination des variables ou imposent un schéma de dénomination précis. Les noms plus courts sont plus rapides à saisir mais sont moins descriptifs ; les noms plus longs facilitent souvent la lecture des programmes et la compréhension de l'objectif des variables. Cependant, une verbosité extrême dans les noms de variables peut également conduire à un code moins compréhensible.

Nous pouvons classer les variables en fonction de leur durée de vie. Les différents types de variables sont statiques, dynamiques de pile, dynamiques de tas explicites et dynamiques de tas implicites. Une variable statique est également appelée variable globale, elle est liée à une cellule de mémoire avant le début de l'exécution et reste dans la même cellule de mémoire jusqu'à la fin. Un exemple typique est celui des variables statiques en C et C++. Une variable dynamique de pile est appelée variable locale, qui est liée lorsque l'instruction de déclaration est exécutée et elle est désallouée lorsque la procédure revient. Les principaux exemples sont les variables locales dans les sous-programmes C et les méthodes Java. Les variables dynamiques de tas explicites sont des cellules de mémoire sans nom (abstraites) qui sont allouées et désallouées par des instructions d'exécution explicites spécifiées par le programmeur. Les principaux exemples sont les objets dynamiques en C++ (via new et delete) et tous les objets en Java. Les variables dynamiques de tas implicites sont liées au stockage de tas uniquement lorsqu'elles reçoivent des valeurs. L'allocation et la libération se produisent lorsque des valeurs sont réaffectées aux variables. Par conséquent, les variables dynamiques de tas implicites ont le plus haut degré de flexibilité. Les principaux exemples sont certaines variables en JavaScript, PHP et toutes les variables en APL.