Variable (langage de programmation de haut niveau)
Dans certains langages de programmation de haut niveau , une variable est un emplacement de stockage abstrait, associé à un nom symbolique , qui contient une quantité connue ou ...
Worldlex WikiFrancaisLecture gratuite
Dans certains langages de programmation de haut niveau , une variable est un emplacement de stockage abstrait, associé à un nom symbolique , qui contient une quantité connue ou inconnue de données ou un objet appelé valeur ; en d'autres termes, une variable est un conteneur nommé pour un ensemble particulier de bits ou un type de données (comme un entier , un nombre à virgule flottante , une chaîne de caractères , etc.) ou une valeur indéfinie . Dans d'autres langages tels que BASIC, Python ou Ruby, une variable est plus précisément décrite comme un nom associé à une valeur, l'allocation de mémoire étant gérée de manière transparente par l'interpréteur ou l'environnement d'exécution. Une variable peut être associée à une adresse mémoire ou identifiée par celle-ci . Le nom de la variable est la manière habituelle de référencer la valeur stockée, en plus de la variable elle-même, selon le contexte. Cette séparation entre le nom et le contenu permet d'utiliser le nom indépendamment de l'information exacte qu'il représente. L'identifiant dans le code source peut être lié à une valeur lors de l'exécution , et la valeur de la variable peut donc changer au cours de l' exécution du programme .
En programmation, les variables ne correspondent pas nécessairement au concept de variable en mathématiques . Ce dernier est abstrait et ne fait référence à aucun objet physique, comme un emplacement de stockage. La valeur d'une variable informatique ne fait pas forcément partie d'une équation ou d'une formule, contrairement aux mathématiques. De plus, les variables peuvent être des constantes si leur valeur est définie statiquement. En programmation, les variables portent souvent des noms longs, plus descriptifs, tandis qu'en mathématiques, elles sont généralement désignées par des noms courts, d'un ou deux caractères, pour faciliter la transcription et la manipulation.
L'emplacement de stockage d'une variable peut être référencé par plusieurs identificateurs différents ; on parle alors d' alias . L'affectation d'une valeur à la variable à l'aide de l'un de ces identificateurs modifiera la valeur accessible via les autres identificateurs.
Les compilateurs doivent remplacer les noms symboliques des variables par l'emplacement réel des données. Si le nom, le type et l'emplacement d'une variable restent généralement fixes, les données qui y sont stockées peuvent être modifiées lors de l'exécution du programme.
Selon le système de types d'un langage de programmation, les variables peuvent être limitées à un type de données spécifique (par exemple, entier ou chaîne de caractères ). Il est également possible qu'un type de données soit associé uniquement à sa valeur actuelle, permettant ainsi à une variable unique de stocker n'importe quel type pris en charge par le langage. Les variables servent de conteneurs pour le stockage des valeurs.
Variables et portée :
Variables automatiques : Chaque variable locale d’une fonction est créée uniquement lors de l’appel de la fonction et disparaît à la sortie de celle-ci. Ces variables sont dites automatiques.
Variables externes : il s’agit de variables extérieures à une fonction et accessibles par leur nom depuis n’importe quelle fonction. Ces variables persistent ; contrairement aux variables qui apparaissent et disparaissent lors de l’exécution des fonctions, elles conservent leur valeur même après le retour de la fonction qui les a initialisées.
Identifiants faisant référence à une variable
Un identifiant faisant référence à une variable peut être utilisé pour accéder à la variable afin de lire sa valeur, de la modifier ou d'éditer d'autres attributs de la variable, tels que les autorisations d'accès, les verrous , les sémaphores , etc.
Par exemple, une variable peut être référencée par l'identificateur «Si une variable n'est référencée que par un seul identificateur, cet identificateur peut simplement être appelé le nom de la variable ; sinon, on peut parler de l' un des noms de la variable . Par exemple, dans l'exemple précédent, l'identificateur «
Portée et étendue
def add_two ( x : int ) -> int : return x + 2print ( add_two ( 5 )) # affiche : 7
La variable nommée paramètre car elle reçoit une valeur lors de l'appel de la fonction. L'entier 5 est l' argument auquel elle attribue
Allocation de mémoire
Les modalités d'allocation des variables et la représentation de leurs valeurs varient considérablement, tant entre les langages de programmation qu'entre les implémentations d'un même langage. De nombreuses implémentations allouent de l'espace aux variables locales , dont la taille est limitée à un seul appel de fonction sur la pile d'appels et dont la mémoire est automatiquement libérée au retour de la fonction. Plus généralement, dans le cas de la liaison de nom , le nom d'une variable est lié à l'adresse d'un bloc mémoire spécifique (séquence contiguë) et les opérations sur la variable manipulent ce bloc. Le référencement est plus courant pour les variables dont la taille est importante ou inconnue à la compilation. Ces variables référencent l'emplacement de la valeur au lieu de stocker la valeur elle-même, qui est allouée dans un pool de mémoire appelé tas .
Les variables liées possèdent des valeurs. Une valeur est toutefois une abstraction, une idée ; concrètement, elle est représentée par un objet de données stocké en mémoire. Le programme, ou l' environnement d'exécution , doit allouer de la mémoire à chaque objet de données et, la mémoire étant limitée, s'assurer de sa libération lorsque l'objet n'est plus nécessaire pour représenter la valeur d'une variable.
Les objets alloués sur le tas doivent être libérés , notamment lorsqu'ils ne sont plus nécessaires. Dans les langages dotés d'un ramasse-miettes (comme C# , Java , Python, Go et Lisp ), l'environnement d'exécution libère automatiquement les objets lorsque des variables existantes ne peuvent plus y faire référence. Dans les langages sans ramasse-miettes, comme C , le programme (et le programmeur) doivent allouer explicitement la mémoire, puis la libérer ultérieurement. Ne pas le faire entraîne des fuites de mémoire : le tas se vide pendant l'exécution du programme, ce qui risque de provoquer une panne par saturation 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 sont accessibles qu'indirectement via cette variable. Dans ce cas, le ramasse-miettes (ou des fonctionnalités équivalentes dans les langages qui en sont dépourvus) doit gérer le cas où seule une partie de la mémoire accessible depuis la variable doit être libérée.
Conventions d'appellation
Contrairement à leurs homologues mathématiques, les variables et constantes de programmation prennent généralement des noms à plusieurs caractères, par exemple `x` d'index de tableau .
Certaines conventions de nommage sont imposées au niveau du langage, car elles font partie intégrante de sa syntaxe et définissent le format des identificateurs valides. Dans la quasi-totalité des langages, les noms de variables ne peuvent commencer par un chiffre (0 à 9) ni contenir d'espaces. L'autorisation ou non de la ponctuation dans les noms de variables varie d'un langage à l'autre ; nombre d'entre eux n'autorisent que le trait de soulignement (« _ ») et interdisent toute autre ponctuation. Dans certains langages de programmation, des sigils (symboles ou signes de ponctuation) sont ajoutés aux identificateurs de variables pour indiquer leur type de données ou leur portée.
La sensibilité à la casse des noms de variables varie également d'un langage à l'autre, certains langages imposant une casse particulière pour nommer certaines entités ; La plupart des langages modernes sont sensibles à la casse ; certains langages plus anciens ne le sont pas. Certains langages réservent certaines formes de noms de variables à leur usage interne ; dans de nombreux langages, les noms commençant par deux traits de soulignement (« __ ») entrent souvent dans cette catégorie.
Cependant, au-delà des restrictions fondamentales imposées par un langage, le choix des noms de variables relève en grande partie du style. Au niveau du code machine , les noms de variables ne sont pas utilisés ; par conséquent, les noms exacts choisis n’ont aucune importance pour l’ordinateur. Ainsi, les noms de variables servent à les identifier ; pour le reste, ils ne sont qu’un outil permettant aux programmeurs de simplifier l’écriture et la compréhension des programmes. Utiliser des noms de variables mal choisis peut rendre le code plus difficile à relire que des noms non descriptifs ; c’est pourquoi des noms clairs sont souvent recommandés.
Les programmeurs élaborent et respectent souvent des conventions de style de code qui fournissent des indications sur la dénomination des variables ou imposent une convention précise. Les noms courts sont plus rapides à saisir, mais moins descriptifs ; les noms longs facilitent généralement la lecture du programme et la compréhension du rôle des variables. Cependant, une verbosité excessive dans les noms de variables peut également rendre le code moins compréhensible.
Types de variables (en fonction de la durée de vie)
On peut classer les variables selon leur durée de vie. Il existe différents types de variables : statiques, dynamiques sur la pile, dynamiques sur le tas explicites et dynamiques sur le tas implicites. Une variable statique , aussi appelée variable globale, est liée à une cellule mémoire avant le début de l'exécution et y reste jusqu'à la fin. Les variables statiques en C et C++ en sont un exemple typique. Une variable dynamique sur la pile, ou variable locale, est liée lors de l'exécution de son instruction de déclaration et libérée à la fin de la procédure. Les variables locales dans les sous-programmes C et les méthodes Java en sont des exemples typiques. Les variables dynamiques sur le tas explicites sont des cellules mémoire sans nom (abstraites) allouées et libérées par des instructions d'exécution explicites spécifiées par le programmeur. Les objets dynamiques en C++ (via `new` et `delete`) et tous les objets en Java en sont des exemples typiques. Les variables dynamiques sur le tas implicites sont liées à la mémoire du tas uniquement lorsqu'une valeur leur est assignée. L'allocation et la libération ont lieu lors de la réaffectation des valeurs. De ce fait, les variables dynamiques sur le tas implicites offrent la plus grande flexibilité. Les principaux exemples sont certaines variables en JavaScript, PHP et toutes les variables en APL.
Worldlex Wiki