Lokale und Globale Scopes

An diesem Punkt ist es wichtig, sich mit dem Konzept der Gültigkeitsbereiche zu befassen, um die Bereiche zu verstehen, in denen auf bestimmte Variablen (oder Konstanten) zugegriffen werden kann und wo nicht.

Der Gültigkeitsbereich einer Variablen oder Konstante definiert, wo sie verwendet werden kann.

Wenn eine Variable oder Konstante außerhalb eines Codeblocks deklariert wird, wird sie im gesamten Programm zugänglich und erhält das Label eines globalen Gültigkeitsbereichs. Im folgenden Code-Snippet veranschaulicht die Konstante pi diesen globalen Gültigkeitsbereich:

index


              12345678
            
package main
import "fmt"

const pi float32 = 3.1415

func main() {
      fmt.Println(pi)
}

Umgekehrt, wenn eine Variable oder Konstante innerhalb eines Codeblocks deklariert wird, bleibt sie ausschließlich innerhalb dieses spezifischen Codeblocks und aller verschachtelten Codeblöcke, falls zutreffend, zugänglich.

Die folgende Abbildung zeigt die Unterschiede zwischen globalen und lokalen Gültigkeitsbereichen:

Der folgende Code zeigt Bereiche, in denen der Zugriff auf Variablen erlaubt ist und wo Fehler auftreten können:

index


              12345678910111213141516171819202122232425262728
            
package main
import "fmt"

func main() {
      var value_1 int = 1
     
      // Condition 1
      if(true) {
            var value_2 int = 2
           
            // Condition 2
            if (true) {
                  var value_3 int = 3
                 
                  fmt.Println("In Condition 2:", value_1)      
                  fmt.Println("In Condition 2:", value_2)
                  fmt.Println("In Condition 2:", value_3)
            }
           
            fmt.Println("In Condition 1:", value_1)
            fmt.Println("In Condition 1:", value_2)
            fmt.Println("In Condition 1:", value_3) // Error here
      }
     
      fmt.Println("In Main:", value_1)
      fmt.Println("In Main:", value_2) // Error here
      fmt.Println("In Main:", value_3) // Error here
}

Die Variable value_1 bleibt im gesamten main()-Codeblock zugänglich, einschließlich innerhalb verschachtelter Codeblöcke wie Bedingung 1 und Bedingung 2. Sie ist auch innerhalb von Bedingung 1 und ihrer verschachtelten Bedingung 2 zugänglich.

Der Versuch, sie direkt außerhalb des main()-Blocks zuzugreifen, führt jedoch zu einem Fehler. Ebenso ist die Variable value_2, die innerhalb von Bedingung 2 deklariert wird, nur innerhalb dieses spezifischen Codeblocks zugänglich.

Es ist entscheidend, Gültigkeitsbereiche im Kontext von Funktionen zu berücksichtigen. Wenn wir eine Variable oder Konstante innerhalb einer Funktion deklarieren, bleibt sie auf diese Funktion beschränkt und ist in anderen Funktionen, einschließlich main(), nicht zugänglich.

Hinweis

main() fungiert als automatisch ausgeführte Funktion, wenn das Programm ausgeführt wird.

index


              12345678
            
func myFunc() {
      var number int = 7
      fmt.Println(number) // Accessible here
}

func main() {
      fmt.Println(number) // Not accessible here
}

Ein weiterer wichtiger Punkt, den man beachten sollte, ist, dass wir nicht zwei oder mehr Variablen mit demselben Namen innerhalb desselben Gültigkeitsbereichs oder sich überschneidender Gültigkeitsbereiche deklarieren können.

index


              1234567891011
            
func myFunc1() {
      var number int = 7
      var number int = 9 // Error here
}

func myFunc2() {
      var number int = 7
      if(2 > 1) {
            var number int = 9 // Error here
      }
}

Es ist jedoch möglich, Variablen mit demselben Namen in verschiedenen Gültigkeitsbereichen zu deklarieren:

index


              1234567891011121314151617
            
package main
import "fmt"

func myFunc1() {
      var number int = 7
      fmt.Println("In Func 1:", number)
}

func myFunc2() {
      var number int = 9
      fmt.Println("In Func 2:", number)
}

func main() {
      myFunc1()
      myFunc2()
}

War alles klar?

Danke für Ihr Feedback!

Abschnitt 4. Kapitel 2