Les variables dans n'importe quel langage de programmation ont un rôle crucial. Les variables sont classées en variables globales et variables locales en fonction de leur portée. La principale différence entre les variables globales et locales est que les variables globales sont accessibles globalement dans l'ensemble du programme, tandis que les variables locales ne sont accessibles que dans la fonction ou le bloc dans lequel elles sont définies. Dans cette rubrique, nous comprendrons d'abord quelles sont les variables et la portée, ainsi que les variables locales, les variables globales, puis les différences entre les deux variables.

Qu'est-ce qu'une variable ?

Une variable est un nom donné à un emplacement mémoire pour stocker des valeurs dans un programme informatique. Il est utilisé pour stocker des informations pouvant être référencées et manipulées dans un programme.

Nous pouvons choisir n'importe quel nom pour la variable, mais il doit suivre la sémantique de programmation. Tel que cela peut être , a, b, x, y, z, sous, div, total, moyenne, etc. .

Disons qu'il y a deux valeurs, 10 et 20, que nous souhaitons stocker et utiliser dans notre programme. Pour cela, nous devons utiliser une variable et nous suivrons les étapes ci-dessous :

• Tout d’abord, nous allons créer ou déclarer une variable avec un nom approprié.
• Attribuez ces valeurs aux variables pour les stocker.
• Une fois ces valeurs stockées, nous pouvons utiliser ces variables avec leur nom dans notre programme.

Comme nous pouvons le voir dans l'image ci-dessus, il y a deux emplacements mémoire, 001 et 002, et nous avons donné à ces emplacements les noms A et B. A contient 10 et B en contient 20.

jlist

Différents langages de programmation ont différentes manières de déclarer la variable. Par exemple, en langage C, on peut déclarer la variable de la manière suivante :

Syntaxe : (Syntaxe de déclaration de variable en langage C)

qu'est-ce qu'un hashset en Java

 datatype v1, v2, v3,....; 

Exemple:

 #include void main(){ int a; int b; int sum; } 

Portée de la variable

Chaque variable est définie et peut être utilisée dans sa portée et détermine dans quel programme cette variable peut être utilisée. La portée signifie la durée de vie de cette variable. Cela signifie que la variable n'est accessible ou visible que dans sa portée.

La portée des variables peut être définie avec leur déclaration, et les variables sont déclarées principalement de deux manières :

Variable globale :En dehors de toutes les fonctionsVariable locale:Au sein d'un bloc fonction :

Qu'est-ce qu'une variable globale ?

• Les variables globales sont les variables qui sont déclarées en dehors de toutes les fonctions ou blocs et qui sont accessibles globalement dans un programme.
• Il est accessible par n'importe quelle fonction présente dans le programme.
• Une fois que nous déclarons une variable globale, sa valeur peut varier selon l'utilisation avec différentes fonctions.
• La durée de vie de la variable globale existe jusqu'à l'exécution du programme. Ces variables sont stockées dans des emplacements mémoire fixes donnés par le compilateur et ne sont pas automatiquement nettoyées.
• Les variables globales sont principalement utilisées en programmation et utiles dans les cas où toutes les fonctions doivent accéder aux mêmes données.

Exemple:

 #include int a=50, b=40; void main() { printf('a = %d and b=%d',a,b); } 

Dans l'exemple ci-dessus, a et b sont les variables globales.

Avantages de la variable globale

• Les variables globales sont accessibles par toutes les fonctions présentes dans le programme.
• Une seule déclaration est requise.
• Très utile si toutes les fonctions accèdent aux mêmes données.

Inconvénients de la variable globale

• La valeur d'une variable globale peut être modifiée accidentellement car elle peut être utilisée par n'importe quelle fonction du programme.
• Si nous utilisons un grand nombre de variables globales, le risque de génération d’erreurs dans le programme est élevé.

Qu'est-ce qu'une variable locale ?

Les variables déclarées dans ou à l'intérieur d'un bloc fonctionnel sont appelées variables locales.
• Ces variables ne sont accessibles que dans la fonction dans laquelle elles sont déclarées.
• La durée de vie de la variable locale concerne uniquement sa fonction, ce qui signifie que la variable existe jusqu'à l'exécution de la fonction. Une fois l'exécution de la fonction terminée, les variables locales sont détruites et n'existent plus en dehors de la fonction.
• La raison de la portée limitée des variables locales est que les variables locales sont stockées dans la pile, qui est de nature dynamique et nettoie automatiquement les données qui y sont stockées.
• Mais en rendant la variable statique avec le mot-clé 'static', nous pouvons conserver la valeur de la variable locale.

Exemple:

 #include void main() { int x=50, y=40; printf('x = %d and y=%d',x, y); } 

Dans l'exemple ci-dessus, nous avons déclaré x et y deux variables dans la fonction principale. Ce sont donc des variables locales.

Avantages de la variable locale

• Le même nom de variable locale peut être utilisé dans différentes fonctions car il n'est reconnu que par la fonction dans laquelle elle est déclarée.
• Les variables locales utilisent la mémoire uniquement pendant la durée limitée au cours de laquelle la fonction est exécutée ; après cela, le même emplacement mémoire peut être réutilisé.

Inconvénients des variables locales

• La portée de la variable locale est limitée à sa fonction uniquement et ne peut pas être utilisée par d'autres fonctions.
• Le partage de données par la variable locale n'est pas autorisé.

Tableau de comparaison entre la variable globale et la variable locale

Exemples pour comprendre les différences entre les variables locales et globales

Voyons maintenant des exemples dans différents langages de programmation pour mieux comprendre la différence entre les variables locales et globales.

parcours d'arbre

Local vs Global en C

Exemple 1:

 #include // Global variables int a; int b; int Add() { return a + b; } int Mul() { int c=10; //Local Variable int d=20; ////Local Variable return c*d; } void main() { int Ans1, Ans2, c=30;// Local variable a = 50; b = 70; Ans1 = Add(); Ans2= Mul(); printf('The addition result is: %d
',Ans1); printf('The Multiplication result is: %d
',Ans2); printf('%d
', c); } 

Sortir:

redémarrer MySQL Ubuntu

 The addition result is: 120 The Multiplication result is: 200 30 

Comme nous pouvons le voir dans le programme ci-dessus, nous avons pris un et b variables globales accessibles dans différentes fonctions telles que Add() et main(). Alors qu'il existe également des variables locales telles que c, d, Ans1 et Ans2, auxquelles n'accèdent que les fonctions dans lesquelles elles sont déclarées.

Si nous essayons d'utiliser les variables c et d en dehors de la fonction Mul(), elles seront utilisées comme nouvelles variables. Comme nous l'avons montré en prenant également c dans la fonction main(), elle est traitée comme une nouvelle variable.

Local contre. Global en Python

Exemple 1:

 v1 = 'Hey, I am Global Variable!, I can be used everywhere in the program.' #globalvariable def func1(): v2='Hey, I am Local Variable!, I can be used within this block only in the program.' #localvariable print(v2) func1() #calling func1 def func2(): print(v1) func2() #callin func2 

Sortir:

 Hey, I am a Local Variable!, I can be used within this block only in the program. Hey, I am Global Variable!, I can be used everywhere in the program. 

Dans le programme ci-dessus, nous avons pris une variable globale v1 et une variable locale v2. Puisque la v1 est globale, elle est facilement accessible dans n'importe quelle fonction, et la v2 est locale ; il n'est utilisé que dans le cadre de sa fonction déclarée. Mais si nous essayons d'utiliser la v1 dans func1, cela donnera une erreur. Voyons l'exemple ci-dessous :

Exemple-2

 v1 = 'Hey, I am Global Variable!, I can be used everywhere in the program.' #globalvariable def func1(): v2='Hey, I am Local Variable!, I can be used within this block only in the program.' #localvariable print(v2) print(v1) func1() #calling func1 def func2(): print(v1) print(v2) func2() #callin func2 

Si nous essayons d'accéder à la v1, elle est facilement accessible dans fun1 et func2. Mais si nous essayons d'accéder à la v2 en dehors de sa fonction, c'est-à-dire dans func2, cela donnera l'erreur d'exécution. Nous obtiendrons le résultat ci-dessous après avoir exécuté le code ci-dessus :

Erreur d'exécution:

Rohit Shetty acteur

 NameError: global name 'v2' is not defined 

Sortir:

 Hey, I am Local Variable!, I can be used within this block only in the program. Hey, I am Global Variable!, I can be used everywhere in the program. Hey, I am Global Variable!, I can be used everywhere in the program. 

Local contre. Variable globale en Java

En Java, il n’existe pas de concept de variables globales ; puisque Java est un langage de programmation orienté objet, tout fait partie de la classe. Mais si nous voulons rendre une variable accessible globalement, nous pouvons la rendre statique en utilisant un statique Mot-clé.

 class Demo { // static variable static int a = 10; // non-static or local variable int b = 20; } public class Main { public static void main(String[] args) { Demo obj = new Demo(); // accessing the non-static variable System.out.println('Value of non-static variable is: ' + (obj.b)); // accessing the static variable System.out.println('Value of static variable is:' + (Demo.a)); } } 

Sortir:

 Value of non-static variable is: 20 Value of static variable is:10 

Dans le programme ci-dessus, nous avons utilisé une variable locale ou variable non statique et une variable statique. La variable locale est accessible en utilisant l'objet de la classe Demo, tandis que la variable statique est accessible en utilisant le nom de la classe.