Variablen spielen in jeder Programmiersprache eine entscheidende Rolle. Variablen werden basierend auf ihrem Umfang in globale Variablen und lokale Variablen klassifiziert. Der Hauptunterschied zwischen globalen und lokalen Variablen besteht darin, dass auf globale Variablen global im gesamten Programm zugegriffen werden kann, während auf lokale Variablen nur innerhalb der Funktion oder des Blocks zugegriffen werden kann, in dem sie definiert sind. In diesem Thema werden wir zunächst verstehen, was die Variablen und deren Umfang sind, zusammen mit lokalen Variablen, globalen Variablen und dann den Unterschieden zwischen beiden Variablen.

Was ist eine Variable?

Eine Variable ist ein Name, der einem Speicherort zum Speichern von Werten in einem Computerprogramm gegeben wird. Es wird zum Speichern von Informationen verwendet, die in einem Programm referenziert und bearbeitet werden können.

Wir können einen beliebigen Namen für die Variable wählen, er muss jedoch der Programmiersemantik folgen. So wie es sein kann , a, b, x, y, z, sub, div, total, avg usw .

Nehmen wir an, es gibt zwei Werte, 10 und 20, die wir speichern und in unserem Programm verwenden möchten. Dazu müssen wir eine Variable verwenden und führen die folgenden Schritte aus:

• Zuerst erstellen oder deklarieren wir eine Variable mit einem passenden Namen.
• Weisen Sie diese Werte den Variablen zu, um sie zu speichern.
• Sobald diese Werte gespeichert sind, können wir diese Variablen mit ihrem Namen in unserem Programm verwenden.

Wie wir im obigen Bild sehen können, gibt es zwei Speicherplätze, 001 und 002, und wir haben diesen Speicherorten die Namen A und B gegeben. A enthält 10 und B enthält 20.

Verschiedene Programmiersprachen haben unterschiedliche Möglichkeiten, die Variable zu deklarieren. In der Sprache C können wir die Variable beispielsweise wie folgt deklarieren:

Syntax: (Variablendeklarationssyntax in C-Sprache)

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

Beispiel:

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

Umfang der Variablen

Jede Variable ist definiert und kann innerhalb ihres Gültigkeitsbereichs verwendet werden und bestimmt, in welchem ​​Programm diese Variable zur Verwendung verfügbar ist. Der Bereich bedeutet die Lebensdauer dieser Variablen. Dies bedeutet, dass auf die Variable nur innerhalb ihres Gültigkeitsbereichs zugegriffen werden kann oder sie sichtbar ist.

Der Umfang von Variablen kann mit ihrer Deklaration definiert werden, und Variablen werden hauptsächlich auf zwei Arten deklariert:

Globale Variable:Außerhalb aller FunktionenLokale Variable:Innerhalb eines Funktionsblocks:

Was ist eine globale Variable?

• Globale Variablen sind solche Variablen, die außerhalb aller Funktionen oder Blöcke deklariert werden und auf die global in einem Programm zugegriffen werden kann.
• Es kann von jeder im Programm vorhandenen Funktion aufgerufen werden.
• Sobald wir eine globale Variable deklariert haben, kann ihr Wert je nach Verwendung mit verschiedenen Funktionen variiert werden.
• Die Lebensdauer der globalen Variablen bleibt bestehen, bis das Programm ausgeführt wird. Diese Variablen werden an festen, vom Compiler vorgegebenen Speicherorten gespeichert und werden nicht automatisch bereinigt.
• Globale Variablen werden hauptsächlich in der Programmierung verwendet und sind dann nützlich, wenn alle Funktionen auf dieselben Daten zugreifen müssen.

Beispiel:

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

Im obigen Beispiel sind a und b die globalen Variablen.

C

Vorteile der globalen Variablen

• Auf globale Variablen kann von allen im Programm vorhandenen Funktionen zugegriffen werden.
• Es ist nur eine einzige Erklärung erforderlich.
• Sehr nützlich, wenn alle Funktionen auf dieselben Daten zugreifen.

Nachteile der globalen Variablen

• Der Wert einer globalen Variablen kann versehentlich geändert werden, da er von jeder Funktion im Programm verwendet werden kann.
• Wenn wir eine große Anzahl globaler Variablen verwenden, besteht eine hohe Wahrscheinlichkeit, dass im Programm Fehler generiert werden.

Was ist eine lokale Variable?

Variablen, die innerhalb oder innerhalb eines Funktionsblocks deklariert werden, werden als lokale Variablen bezeichnet.
• Auf diese Variablen kann nur innerhalb der Funktion zugegriffen werden, in der sie deklariert sind.
• Die Lebensdauer der lokalen Variablen liegt nur innerhalb ihrer Funktion, was bedeutet, dass die Variable existiert, bis die Funktion ausgeführt wird. Sobald die Funktionsausführung abgeschlossen ist, werden lokale Variablen zerstört und sind außerhalb der Funktion nicht mehr vorhanden.
• Der Grund für den begrenzten Umfang lokaler Variablen liegt darin, dass lokale Variablen im Stapel gespeichert werden, der dynamischer Natur ist und die darin gespeicherten Daten automatisch bereinigt.
• Indem wir die Variable jedoch mit dem Schlüsselwort „static“ statisch machen, können wir den Wert der lokalen Variablen beibehalten.

Beispiel:

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

Im obigen Beispiel haben wir x und y als zwei Variablen innerhalb der Hauptfunktion deklariert. Es handelt sich also um lokale Variablen.

Vorteile der lokalen Variablen

• Der gleiche Name einer lokalen Variablen kann in verschiedenen Funktionen verwendet werden, da er nur von der Funktion erkannt wird, in der er deklariert ist.
• Lokale Variablen nutzen den Speicher nur für die begrenzte Zeit, in der die Funktion ausgeführt wird. Danach kann derselbe Speicherort wiederverwendet werden.

Nachteile lokaler Variablen

• Der Gültigkeitsbereich der lokalen Variablen ist nur auf ihre Funktion beschränkt und kann nicht von anderen Funktionen verwendet werden.
• Die gemeinsame Nutzung von Daten durch die lokale Variable ist nicht zulässig.

Vergleichstabelle zwischen globaler Variable und lokaler Variable

Beispiele zum Verständnis der Unterschiede zwischen lokalen und globalen Variablen

Lassen Sie uns nun Beispiele in verschiedenen Programmiersprachen verstehen, um den Unterschied zwischen lokalen und globalen Variablen besser zu verstehen.

Lokal vs. global in C

Beispiel 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); } 

Ausgabe:

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

Wie wir im obigen Programm sehen können, haben wir genommen A Und B globale Variablen, auf die in verschiedenen Funktionen wie Add() und main() zugegriffen wird. Dagegen gibt es auch lokale Variablen wie c, d, Ans1 und Ans2, auf die nur von den Funktionen zugegriffen wird, in denen sie deklariert sind.

Wenn wir versuchen, c- und d-Variablen außerhalb der Mul()-Funktion zu verwenden, werden sie als neue Variablen verwendet. Wie wir durch die Verwendung von c auch in der Funktion main() gezeigt haben, wird es als neue Variable behandelt.

Versuchen Sie es mit Catch Catch Java

Lokal vs. Global in Python

Beispiel 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 

Ausgabe:

 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. 

Im obigen Programm haben wir eine globale Variable v1 und eine lokale Variable v2 verwendet. Da v1 global ist, kann in jeder Funktion problemlos darauf zugegriffen werden, und v2 ist lokal. Es wird nur innerhalb seiner deklarierten Funktion verwendet. Wenn wir jedoch versuchen, v1 in func1 zu verwenden, wird ein Fehler ausgegeben. Sehen wir uns das folgende Beispiel an:

Beispiel-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 

Wenn wir versuchen, auf v1 zuzugreifen, können wir problemlos in fun1 und func2 darauf zugreifen. Wenn wir jedoch versuchen, außerhalb seiner Funktion, also in func2, auf v2 zuzugreifen, wird der Laufzeitfehler angezeigt. Nach der Ausführung des obigen Codes erhalten wir die folgende Ausgabe:

Laufzeit Fehler:

 NameError: global name 'v2' is not defined 

Ausgabe:

 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. 

Lokal vs. Globale Variable in Java

In Java gibt es kein Konzept globaler Variablen; Da Java eine objektorientierte Programmiersprache ist, ist alles Teil der Klasse. Wenn wir jedoch eine Variable global zugänglich machen möchten, können wir sie mithilfe von a statisch machen statisch Stichwort.

 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)); } } 

Ausgabe:

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

Im obigen Programm haben wir eine lokale Variable oder nicht statische Variable und eine statische Variable verwendet. Auf die lokale Variable kann über das Objekt der Demo-Klasse zugegriffen werden, während auf die statische Variable über den Namen der Klasse zugegriffen werden kann.