Es gibt verschiedene Arten von Variablen in der Go-Sprache

Es gibt drei Arten von Variablen: 1. Variablen, die innerhalb einer Funktion definiert sind, werden lokale Variablen genannt und ihr Gültigkeitsbereich ist nicht immer auf das Innere der Funktion beschränkt. Sie existieren erst, nachdem die Funktion, die sie definiert, vorhanden ist aufgerufen und nach Beendigung des Funktionsaufrufs wird diese lokale Variable zerstört. 2. Außerhalb der Funktion definierte Variablen werden als globale Variablen bezeichnet. Sie müssen nur in einer Quelldatei definiert werden und können in allen Quelldateien verwendet werden. Wenn Sie die globale Variable verwenden möchten in einem externen Paket Der erste Buchstabe einer Variablen muss großgeschrieben werden. 3. Die Variablen in der Funktionsdefinition werden formale Parameter genannt.

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

Go-Sprache ist eine statisch typisierte Sprache, daher haben Variablen klare Typen und der Compiler überprüft auch die Richtigkeit des Variablentyps. In mathematischen Konzepten stellt eine Variable eine Zahl dar, die keinen festen Wert hat und geändert werden kann. Aus Sicht der Computersystemimplementierung handelt es sich bei einer Variablen jedoch um ein oder mehrere Speichersegmente, die zum Speichern von Daten verwendet werden.

Eine Variable (Konstante, Typ oder Funktion) hat einen bestimmten Gültigkeitsbereich im Programm, der als Gültigkeitsbereich bezeichnet wird.

Um die Go-Sprache zu lernen, ist es für uns wichtiger, den Umfang der Variablen zu verstehen, da die Go-Sprache prüft, ob jede Variable während der Kompilierung verwendet wurde. Sobald eine nicht verwendete Variable angezeigt wird, wird ein Kompilierungsfehler gemeldet. Wenn Sie den Umfang der Variablen nicht verstehen, kann es zu unerklärlichen Kompilierungsfehlern kommen.

Je nachdem, wo die Variable definiert ist, kann sie in die folgenden drei Typen unterteilt werden:

• Variablen, die innerhalb der Funktion definiert sind, werden lokale Variablen genannt

• Variablen, die außerhalb der Funktion definiert sind, werden globale Variablen genannt

• In der Funktionsdefinition werden die Variablen als formale Parameter bezeichnet.

Lassen Sie uns sie im Folgenden separat vorstellen.

Lokale Variablen

Variablen, die innerhalb einer Funktion deklariert/definiert werden, werden lokale Variablen genannt, und der Geltungsbereich lokaler Variablen ist auf das Innere der Funktion beschränkt. Innerhalb der Funktion definierte Variablen, Parameter und Rückgabewerte der Funktion, innerhalb der if- und for-Strukturen verwendete Variablen usw. sind allesamt lokale Variablen.

Eine lokale Variable existiert nicht immer. Sie existiert erst, nachdem die Funktion, die sie definiert, aufgerufen wird. Diese lokale Variable wird nach Beendigung des Funktionsaufrufs zerstört.

【Beispiel】Die folgende main()-Funktion verwendet lokale Variablen a, b und c.

package main
import (
    "fmt"
)
func main() {
    //声明局部变量 a 和 b 并赋值
    var a int = 3
    var b int = 4
    //声明局部变量 c 并计算 a 和 b 的和
    c := a + b
    fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
}

Verwenden Sie {}, um den Bereich der Variablen zu begrenzen.

package main
import "fmt"
func main() {
	{
		name := "HaiCoder"
		fmt.Println("Name =", name)
	}
}

Wir verwenden {}, um den Bereich des Variablennamens auf {} zu beschränken, d. h. auf den Bereich des Variablennamens Zu diesem Zeitpunkt befindet sich der Name nur innerhalb von {} und ist eine lokale Variable.

Hinweis: Beim Zugriff auf eine Variable außerhalb des Gültigkeitsbereichs einer Variablen meldet das Programm einen Fehler

package main
import "fmt"
func main() {
	for i := 0; i < 3; i++{
		fmt.Print(i)
		fmt.Print(" ")
	}
	fmt.Print(i)
}

Wir definieren eine lokale Variable i innerhalb der for-Schleife und verwenden sie zu diesem Zeitpunkt im Gültigkeitsbereich der Variablen i ist auf den {} der internen for-Schleife beschränkt. Wenn wir schließlich außerhalb {} der for-Schleife auf die Variable i zugreifen, meldet das Programm einen Fehler, da die Variable i den Gültigkeitsbereich überschreitet.

Globale Variablen

Variablen, die außerhalb der Funktion deklariert werden, werden als globale Variablen bezeichnet und müssen nur in einer Quelldatei definiert werden. Diese globale Variable ist natürlich nicht enthalten Die Quelldatei muss das Schlüsselwort „import“ verwenden, um die Quelldatei einzuführen, in der sich die globale Variable befindet, bevor diese globale Variable verwendet werden kann.

Die globale Variablendeklaration muss mit dem Schlüsselwort var beginnen. Wenn Sie die globale Variable in einem externen Paket verwenden möchten, muss der erste Buchstabe großgeschrieben werden.

【Beispiel】Im folgenden Code definiert Zeile 6 die globale Variable c.

package main
import "fmt"
//声明全局变量
var c int
func main() {
    //声明局部变量
    var a, b int
    //初始化参数
    a = 3
    b = 4
    c = a + b
    fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
}

Erläuterung: Globale Variablen und lokale Variablen in Go-Sprachprogrammen können denselben Namen haben, aber lokalen Variablen im Funktionskörper 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)
}

Formale Parameter

Bei der Definition einer Funktion werden die Variablen in Klammern nach dem Funktionsnamen als formale Parameter (bezeichnet als formale Parameter) bezeichnet. Formale Parameter werden erst wirksam, wenn die Funktion aufgerufen wird, und werden nach Abschluss des Funktionsaufrufs zerstört. Wenn die Funktion nicht aufgerufen wird, belegen die formalen Parameter der Funktion keine tatsächlichen Speichereinheiten und haben keine tatsächlichen Werte.

Formale Parameter werden als lokale Variablen der Funktion verwendet.

[Beispiel] Zeile 21 des folgenden Codes definiert die formalen Parameter a und b.

package main
import (
    "fmt"
)
//全局变量 a
var a int = 13
func main() {
    //局部变量 a 和 b
    var a int = 3
    var b int = 4
    fmt.Printf("main() 函数中 a = %d\n", a)
    fmt.Printf("main() 函数中 b = %d\n", b)
    c := sum(a, b)
    fmt.Printf("main() 函数中 c = %d\n", c)
}
func sum(a, b int) int {
    fmt.Printf("sum() 函数中 a = %d\n", a)
    fmt.Printf("sum() 函数中 b = %d\n", b)
    num := a + b
    return num
}

【相关推荐：Go视频教程、编程教学】

Das obige ist der detaillierte Inhalt vonEs gibt verschiedene Arten von Variablen in der Go-Sprache. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!