Variable globale - Global variable

En programmation informatique , une variable globale est une variable à portée globale , ce qui signifie qu'elle est visible (donc accessible) dans tout le programme, à moins qu'elle ne soit masquée . L'ensemble de toutes les variables globales est appelé environnement global ou état global. Dans les langages compilés , les variables globales sont généralement des variables statiques , dont l' étendue (durée de vie) correspond à l'intégralité du temps d'exécution du programme, bien que dans les langages interprétés (y compris les interpréteurs de ligne de commande ), les variables globales sont généralement allouées dynamiquement lorsqu'elles sont déclarées, car elles ne sont pas connues en avance.

Dans certaines langues, toutes les variables sont globales, ou globales par défaut, tandis que dans la plupart des langues modernes, les variables ont une portée limitée, généralement une portée lexicale , bien que les variables globales soient souvent disponibles en déclarant une variable au niveau supérieur du programme. Dans d'autres langages, cependant, les variables globales n'existent pas ; ce sont généralement des langages de programmation modulaires qui appliquent une structure de module, ou des langages de programmation orientés objet basés sur des classes qui appliquent une structure de classe.

Utilisation

Les mécanismes d'interaction avec les variables globales sont appelés mécanismes d' environnement global (voir aussi état global ). Le paradigme de l'environnement global est contrasté avec le paradigme de l' environnement local , où toutes les variables sont locales sans mémoire partagée (et donc toutes les interactions peuvent être reconduites au passage de messages ).

Les variables globales sont largement utilisées pour transmettre des informations entre des sections de code qui ne partagent pas de relation appelant/appelé comme les threads concurrents et les gestionnaires de signaux. Les langages (y compris C) où chaque fichier définit un espace de noms implicite éliminent la plupart des problèmes rencontrés avec les langages avec un espace de noms global bien que certains problèmes puissent persister sans encapsulation appropriée. Sans verrouillage approprié (comme avec un mutex ), le code utilisant des variables globales ne sera pas thread-safe, sauf pour les valeurs en lecture seule dans la mémoire protégée .

Variables d'environnement

Les variables d'environnement sont une fonction fournie par certains systèmes d'exploitation . Dans le shell du système d'exploitation ( ksh sous Unix , bash sous Linux , COMMAND.COM sous DOS et CMD.EXE sous Windows ) il s'agit d'une sorte de variable : par exemple, sous Unix et les systèmes apparentés, une variable ordinaire devient une variable d'environnement lorsque le exportmot - clé est utilisé. Le code du programme autre que les shells doit y accéder par des appels d' API , tels que getenv()et setenv().

Ils sont locaux au processus dans lequel ils ont été définis. Cela signifie que si nous ouvrons deux fenêtres de terminal (Deux processus différents exécutant le shell) et modifions la valeur de la variable d'environnement dans une fenêtre, ce changement ne sera pas vu par l'autre fenêtre.

Lorsqu'un processus enfant est créé, il hérite de toutes les variables d'environnement et de leurs valeurs du processus parent. Habituellement, lorsqu'un programme appelle un autre programme, il crée d'abord un processus enfant en forking , puis l'enfant ajuste l'environnement selon les besoins et enfin l'enfant se remplace par le programme à appeler. Les processus enfants ne peuvent donc pas utiliser de variables d'environnement pour communiquer avec leurs pairs, évitant ainsi le problème d'action à distance.

Global uniquement et global par défaut

Un certain nombre de langages non structurés , tels que (les premières versions de) BASIC , COBOL et Fortran I (1956) ne fournissent que des variables globales. Fortran II (1958) a introduit des sous-programmes avec des variables locales et le mot-clé COMMON pour accéder aux variables globales. L'utilisation de COMMON dans FORTRAN s'est poursuivie dans FORTRAN 77 et a influencé les langages ultérieurs tels que PL/SQL. Les groupes COMMON nommés pour les globals se comportent un peu comme des espaces de noms structurés. Les variables sont également globales par défaut dans FORTH , Lua , Perl et la plupart des shells.

Par langue

C et C++

Le langage C n'a pas de global mot - clé . Cependant, les variables déclarées en dehors d'une fonction ont une "portée de fichier", ce qui signifie qu'elles sont visibles dans le fichier. Les variables déclarées avec une portée de fichier sont visibles entre leur déclaration et la fin de l'unité de compilation ( .cfichier) (à moins qu'elles ne soient masquées par un objet de même nom dans une portée plus proche, comme une variable locale) ; et ils ont implicitement un lien externe et sont donc visibles non seulement pour le .cfichier ou l' unité de compilation contenant leurs déclarations mais aussi pour toute autre unité de compilation qui est liée pour former le programme complet. La liaison externe, cependant, n'est pas suffisante pour l'utilisation d'une telle variable dans d'autres fichiers : pour qu'une unité de compilation accède correctement à une telle variable globale, elle devra connaître son type. Ceci est accompli en déclarant la variable dans chaque fichier à l'aide du externmot - clé. (Il sera déclaré dans chaque fichier mais ne peut être défini que dans un seul.) De telles externdéclarations sont souvent placées dans un fichier d'en-tête partagé, car il est courant que tous les fichiers .c d'un projet incluent au moins un .hfichier : le fichier standard en-tête errno.hest un exemple, rendant la errnovariable accessible à tous les modules d'un projet. Lorsque ce mécanisme d'accès global est jugé problématique, il peut être désactivé à l'aide du staticmot - clé qui restreint une variable à la portée du fichier, et provoquera des tentatives d'importation avec externpour déclencher une erreur de compilation (ou de liaison).

Un exemple de variable "globale" en C :

#include <stdio.h>

// This is the file-scope variable (with internal linkage), visible only in
// this compilation unit.
static int shared = 3;

// This one has external linkage (not limited to this compilation unit).
extern int over_shared;

// Also internal linkage.
int over_shared_too = 2;

static void ChangeShared() {
  // Reference to the file-scope variable in a function.
  shared = 5;
}

static void LocalShadow() {
  // Local variable that will hide the global of the same name.
  int shared;

  // This will affect only the local variable and will have no effect on the
  // file-scope variable of the same name.
  shared = 1000;
}

static void ParamShadow(int shared) {
  // This will affect only the parameter and will have no effect on the file-
  // scope variable of the same name.
  shared = -shared;
}

int main() {
  // Reference to the file-scope variable.

  printf("%d\n", shared);

  ChangeShared();

  printf("%d\n", shared);

  LocalShadow();

  printf("%d\n", shared);

  ParamShadow(1);

  printf("%d\n", shared);

  return 0;
}

Comme la variable est externe, il n'est pas nécessaire de la passer en paramètre pour l'utiliser dans une fonction autre que main. Il appartient à chaque fonction du module.

La sortie sera :

Java

Certains langages, comme Java, n'ont pas de variables globales. En Java, toutes les variables qui ne sont pas des variables locales sont des champs d'une classe. Par conséquent, toutes les variables sont dans la portée d'une classe ou d'une méthode. En Java, les champs statiques (également appelés variables de classe ) existent indépendamment de toute instance de la classe et une copie est partagée entre toutes les instances ; par conséquent, les champs statiques publics sont utilisés à bon nombre des mêmes fins que les variables globales dans d'autres langages en raison de leur comportement de "partage" similaire :

public class Global {
    public static int a;
}

PHP

PHP a un globalmot-clé et un certain nombre de façons inhabituelles d'utiliser les variables globales. Les variables déclarées en dehors des fonctions ont une portée de fichier (qui est dans la plupart des cas la portée la plus large). Cependant, ils ne sont pas accessibles à l'intérieur des fonctions à moins qu'ils ne soient importés avec le globalmot - clé (c'est-à-dire que le mot-clé accède aux variables globales, il ne les déclare pas).

Cependant, certaines variables prédéfinies, appelées superglobales, sont toujours accessibles. Ce sont tous des tableaux. Un à usage général est le $GLOBALSsuperglobal, qui contient toutes les variables définies hors de la portée de la fonction. Les modifications apportées à ses éléments modifient les variables d'origine et les ajouts créent de nouvelles variables. Les superglobales $_POSTet $_GETsont largement utilisés dans la programmation Web.

Autres langues

En Python et MATLAB, une variable globale peut être déclarée n'importe où avec le globalmot - clé.
Les variables globales de Ruby se distinguent par un sceau ' $' . Il existe un certain nombre de valeurs globales prédéfinies, par exemple l' ID de processus actuel .$$

Languages

In other projects