Es gibt mehrere Bereiche für Go-Sprachvariablen

Go-Sprachvariablen haben zwei Bereiche: 1. Lokale Variablen sind Variablen, die auf Funktionsebene und Blockebene deklariert werden. Auf lokale Variablen kann nur in ihren Blöcken oder Funktionen zugegriffen werden, und deklarierte lokale Variablen können nicht im selben Block sein oder in einem neu deklariert werden Funktion. 2. Globale Variablen sind Variablen, die auf Paketebene deklariert werden. Globale Variablen sind während des gesamten Lebenszyklus des Programms verfügbar und globale Variablen können nicht mit dem Operator „:=" deklariert werden.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, GO Version 1.18, Dell G3-Computer.

Der Speicherort von Variablendeklarationen

Es gibt drei Ebenen von Variablendeklarationen in der Go-Sprache:

• Paketebene: Variablen werden außerhalb der Funktion deklariert
• Funktionsebene: Variablen befinden sich innerhalb der Funktion, einschließlich Funktionsparameter Parameter Variablen, aber außerhalb des Codeblocks deklariert
• Blockebene: Es gibt zwei Arten davon, eine ist explizit und verwendet Code in geschweiften Klammern {}; die andere ist implizit, z. B. die Initialisierung nach dem for- oder if-Ausdruck.

Beispiel für den Speicherort einer Variablen

package main

import "fmt"

var test = "test"  //在函数外，包级别变量

func main() {
    a, b := 1, 2  //a和b，c在main函数内定义，函数级别变量
    c := sum(a, b)
    fmt.Println(c)
    fmt.Println(test)

    for i := 0; i < 10; i++ {   //i为for循环内定义，为隐式块级别变量
        var d = i + 1    //d在for的循环体内，以大括号{}括起来，为显式块级别变量
        fmt.Println(d)
    }

}

func sum(a, b int) int {   //函数参数a和b，在函数内定义，为函数级别变量
    fmt.Println(a)
    fmt.Println(b)
    nu := a + b
    return nu
}

Variablenbereich

Der Speicherort einer Variablendeklaration bestimmt, wo auf die Variable zugegriffen werden darf und den Deklarationszeitraum der Variablen. Der zugängliche Bereich einer Variablen wird als Gültigkeitsbereich der Variablen bezeichnet. In der Go-Sprache ist der Umfang von Variablen in zwei Kategorien unterteilt:

• lokale Variablen, auch lokale Variablen genannt
• globale Variablen

lokale Variablen

Auf Funktionsebene und Blockebene deklarierte Variablen sind lokale Variablen . Lokale Variablen haben die folgenden Eigenschaften:

• Auf lokale Variablen kann nur innerhalb ihres Blocks oder ihrer Funktion zugegriffen werden.
• Lokale Variablen leben nur bis zum Ende des Blocks oder der Funktion, in dem sie deklariert wurden. Anschließend werden sie vom Garbage Collector eingesammelt.
• Lokale Variablen, die deklariert wurden, können nicht im selben Block oder in derselben Funktion erneut deklariert werden.

Beispiel:

package main

import "fmt"

func main() {
    var a= "astrng"
    fmt.Println(a)
    for i := 0; i < 10; i++ {
        fmt.Println(i)
    }
    fmt.Println(i)
}

func testLocal() {
    fmt.Println(a)
}

Dieser Code meldet beim Kompilieren einen Fehler:

undefined: i
undefined: a

Ursache:

i: Es handelt sich um eine lokale Variable auf Blockebene im for-Schleifenkörper, wenn auf sie außerhalb der for-Schleife zugegriffen wird, in der sie definiert ist , undefiniert wird gemeldet.

a: Es handelt sich um eine lokale Variable auf der Hauptfunktionsebene. Auf sie kann innerhalb der testLocal-Funktion nicht zugegriffen werden, und es wird ein undefinierter Fehler gemeldet.

Globale Variablen

Variablen, die auf Paketebene deklariert werden, sind globale Variablen. Globale Variablen haben die folgenden Eigenschaften:

• Wenn eine globale Variable mit Kleinbuchstaben beginnt, kann diese globale Variable nur innerhalb des Pakets verwendet werden, in dem sie definiert ist. Das heißt, die Variablen sind innerhalb des Pakets sichtbar.
• Wenn eine globale Variable mit einem Großbuchstaben beginnt, kann diese globale Variable paketübergreifend verwendet werden. Das heißt, die Variable ist überall sichtbar.
• Globale Variablen sind während des gesamten Lebenszyklus des Programms verfügbar.
• Globale Variablen können nicht mit dem :=-Operator deklariert werden.

package main

import "fmt"

var a = "astring"

func main() {
    testGlobal()
}

func testGlobal() {
    fmt.Println(a)  //运行结果是，正确打印出a的值“astring”
}

Lokale Variablen und globale Variablen haben den gleichen Namen

Globale Variablen und lokale Variablen in Go-Sprachprogrammen können den gleichen Namen haben, aber lokalen Variablen innerhalb des Funktionskörpers wird Priorität eingeräumt.

package main
import "fmt"
//声明全局变量
var a float32 = 3.14
func main() {
    //声明局部变量
    var a int = 3
    fmt.Printf("a = %d\n", a)
}

Die laufenden Ergebnisse sind wie folgt:

a = 3

Die Go-Sprache führt lokale Variablen und globale Variablen mit demselben Namen aus. Die Variable mit demselben Namen befindet sich im lokalen Bereich und überschattet die Variablen im externen Bereich.

package main

import "fmt"

var a = "globala"

func main() {
    var a = "locala"
    fmt.Println(a)  //此处的a会遮蔽外面定义的a全局变量，输出locala
}
func testGlobal() {
  fmt.Println(a)  //此处是全局变量a，输出globala
}

【Verwandte Empfehlungen: Go-Video-Tutorial, Programmierunterricht】

Das obige ist der detaillierte Inhalt vonEs gibt mehrere Bereiche für Go-Sprachvariablen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!