Go - Scope-Regeln

Ein Bereich in jeder Programmierung ist ein Bereich des Programms, in dem eine definierte Variable existieren kann und darüber hinaus nicht auf die Variable zugegriffen werden kann. Es gibt drei Stellen, an denen Variablen in der Programmiersprache Go deklariert werden können:

Innerhalb einer Funktion oder eines Blocks (local Variablen)
Außerhalb aller Funktionen (global Variablen)
Bei der Definition von Funktionsparametern (formal Parameter)

Lassen Sie uns herausfinden, was sind local und global Variablen und was sind formal Parameter.

Lokale Variablen

Variablen, die innerhalb einer Funktion oder eines Blocks deklariert sind, werden als lokale Variablen bezeichnet. Sie können nur von Anweisungen verwendet werden, die sich in dieser Funktion oder diesem Codeblock befinden. Es ist nicht bekannt, dass lokale Variablen außerhalb ihrer eigenen Funktionen funktionieren. Im folgenden Beispiel werden lokale Variablen verwendet. Hier sind alle Variablen a, b und c lokal für die Funktion main ().

package main

import "fmt"

func main() {
   /* local variable declaration */
   var a, b, c int 

   /* actual initialization */
   a = 10
   b = 20
   c = a + b

   fmt.Printf ("value of a = %d, b = %d and c = %d\n", a, b, c)
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

value of a = 10, b = 20 and c = 30

Globale Variablen

Globale Variablen werden außerhalb einer Funktion definiert, normalerweise über dem Programm. Globale Variablen behalten ihren Wert während der gesamten Lebensdauer des Programms und können in allen für das Programm definierten Funktionen aufgerufen werden.

Auf eine globale Variable kann von jeder Funktion zugegriffen werden. Das heißt, eine globale Variable kann nach ihrer Deklaration im gesamten Programm verwendet werden. Im folgenden Beispiel werden sowohl globale als auch lokale Variablen verwendet.

package main

import "fmt"
 
/* global variable declaration */
var g int
 
func main() {
   /* local variable declaration */
   var a, b int

   /* actual initialization */
   a = 10
   b = 20
   g = a + b

   fmt.Printf("value of a = %d, b = %d and g = %d\n", a, b, g)
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

value of a = 10, b = 20 and g = 30

Ein Programm kann für lokale und globale Variablen denselben Namen haben, der Wert der lokalen Variablen in einer Funktion wird jedoch bevorzugt. Zum Beispiel -

package main

import "fmt"
 
/* global variable declaration */
var g int = 20
 
func main() {
   /* local variable declaration */
   var g int = 10
 
   fmt.Printf ("value of g = %d\n",  g)
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

value of g = 10

Formale Parameter

Formale Parameter werden in dieser Funktion als lokale Variablen behandelt und haben Vorrang vor den globalen Variablen. Zum Beispiel -

package main

import "fmt"
 
/* global variable declaration */
var a int = 20;
 
func main() {
   /* local variable declaration in main function */
   var a int = 10
   var b int = 20
   var c int = 0

   fmt.Printf("value of a in main() = %d\n",  a);
   c = sum( a, b);
   fmt.Printf("value of c in main() = %d\n",  c);
}
/* function to add two integers */
func sum(a, b int) int {
   fmt.Printf("value of a in sum() = %d\n",  a);
   fmt.Printf("value of b in sum() = %d\n",  b);

   return a + b;
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

value of a in main() = 10
value of a in sum() = 10
value of b in sum() = 20
value of c in main() = 30

Initialisieren lokaler und globaler Variablen

Lokale und globale Variablen werden auf ihren Standardwert 0 initialisiert. während Zeiger auf Null initialisiert werden.

Datentyp	Anfänglicher Standardwert
int	0
float32	0
Zeiger	Null