Go Sprach-Variable

Ein typisches Programm verwendet verschiedene Werte, die während der Ausführung möglicherweise ändern können.

Zum Beispiel，um bestimmte Operationen mit den von den Benutzern eingegebenen Werten durchzuführen. Ein von einem Benutzer eingegebener Wert kann von einem anderen Benutzer eingegebenen Wert unterschiedlich sein. Daher ist die Verwendung von Variablen erforderlich, da andere Benutzer möglicherweise nicht denselben Wert verwenden. Wenn ein Benutzer einen neuen Wert eingibt, der im Prozess der Operationen verwendet wird, kann dieser vorübergehend im zufälligen Zugriffsspeicher des Computers gespeichert werden. Diese Werte sind in verschiedenen Teilen des Speichers unterschiedlich, daher wird dieser Begriff auch alsVariable。Variable sind Platzhalter für Informationen, die sich während der Ausführung ändern können. Und Variablen ermöglichen die Abfrage und Verarbeitung gespeicherter Informationen.

VariableNamenkonvention:

Der Variablenname muss mit einem Buchstaben oder Unterstrich (_ ) beginnen. Und der Name kann die Buchstaben "a" enthalten.-z" oder "A-Z" oder die Zahl 0-9und dem Zeichen " _".

Geeks, geeks, _geeks23　　//Gültige Variable
123Geeks,　23geeks　　　　　　//　Ungültige Variable

Variablennamen sollten nicht mit einer Zahl beginnen.

234geeks　　//Ungültige Variable

Variablennamen unterscheiden sich in Groß- und Kleinschreibung.

geeks und Geeks sind zwei verschiedene Variablen

Schlüsselwörter dürfen nicht als Variablennamen verwendet werden.

Die Länge des Variablennamens ist nicht begrenzt, aber es wird empfohlen, nur4bis15Die beste Länge eines Buchstaben ist

Variablen deklarieren

In der Programmiersprache Go werden Variablen auf zwei verschiedene Weisen erstellt:

（一）使用var关键字：In der Programmiersprache Go werden Variablen mit spezifischen Typen erstelltvarSchlüsselwort erstellt, das mit dem Variablennamen verknüpft ist und ihm einen Initialwert zuweist.

Syntax:

var variable_name type = expression

Wichtig:

In der obigen Syntax istTyp (type) oder=Der Ausdruck kann entfernt werden, aber nicht beide gleichzeitig aus der Variablendeklaration entfernen.

Wenn der Typ entfernt wird, wird der Typ der Variable durch die Initialisierung des Wertes im Ausdruck bestimmt.

//Konzept der Variablen
package main
import "fmt"
func main() {
　　　　//Variablendeklaration und -initialisierung
　　　　//Expliziter Typ
　　　　var myvariable1　=　20
　　　　var myvariable2　= "w3codebox"
　　　　var myvariable3　=　34.80
　　　　//　Wert und
　　　　//　Typ der Variablen
　　　　fmt.Printf("myvariable1Wert ist: :%d\n", myvariable1)
　　　　fmt.Printf("myvariable1Typ ist: :%T\n", myvariable1)
　　　　fmt.Printf("myvariable2Wert ist: :%s\n", myvariable2)
　　　　fmt.Printf("myvariable2Typ ist: :%T\n", myvariable2)
　　　　fmt.Printf("myvariable3Wert ist: :%f\n", myvariable3)
　　　　fmt.Printf("myvariable3Typ ist: :%T\n", myvariable3)
}

Ausgabe:

myvariable1Wert ist: :　20
myvariable1Typ ist: :int
myvariable2Wert ist: :w3codebox
myvariable2Typ ist: :string
myvariable3Wert ist: :　34.800000
myvariable3der Typ ist: float64

Wenn der Ausdruck entfernt wird, ist der Typ der Variable null, die Zahl null, der boole'sche Wert false, die Zeichenkette""und Referenztypen sind nil. DaherIn der Programmiersprache Go gibt es kein Konzept von nicht initialisierten Variablen.

package main
import "fmt"
func main() {
　　　　//Variablendeklaration und -initialisierung ohne Ausdruck
　　　　var myvariable1　int
　　　　var myvariable2　string
　　　　var myvariable3　float64
　　　　//0-Wert-Variable anzeigen
　　　　fmt.Printf("myvariable1Wert ist: :%d\n", myvariable1)
　　　　fmt.Printf("myvariable2Wert ist: :%d\n", myvariable2)
　　　　fmt.Printf("myvariable3Wert ist: :%d\n", myvariable3)
}

Ausgabe:

myvariable1Wert ist: : 0
myvariable2Wert ist: : !d(string=)
myvariable3Wert ist: : !d(float64=0)

Wenn der Typ verwendet wird, können mehrere Variablen desselben Typs in einer einzigen Deklaration deklariert werden.

package main
import "fmt"
func main() {
　　　　//　Mehrere Variablen desselben Typs werden in einer Zeile deklariert und initialisiert
　　　　var myvariable1, myvariable2, myvariable3　int =　2,　454,　67
　　　　//　Wert der Variable ausgeben
　　　　fmt.Printf("myvariable1Wert ist: :%d\n", myvariable1)
　　　　fmt.Printf("myvariable2Wert ist: :%d\n", myvariable2)
　　　　fmt.Printf("myvariable3Wert ist: :%d\n", myvariable3)
}

Ausgabe:

myvariable1Wert ist: :　2
myvariable2Wert ist: :　454
myvariable3Wert ist: :　67

Wenn der Typ entfernt wird, können mehrere Variablen desselben Typs in einer einzigen Deklaration deklariert werden. Der Typ der Variable wird durch den Wert der Initialisierung bestimmt.

package main
import "fmt"
func main() {
　　　　//Mehrere verschiedene Typen von Variablen
　　　　//Deklaration und Initialisierung in einer Zeile
　　　　var myvariable1, myvariable2, myvariable3　=　2, "GFG",　67.56
　　　　//　Drucke den Wert und den Typ der Variable aus
　　　　fmt.Printf("myvariable1Wert ist: :%d\n", myvariable1)
　　　　fmt.Printf("myvariable1Typ ist: :%T\n", myvariable1)
　　　　fmt.Printf("\nmyvariable2Wert ist: :%s\n", myvariable2)
　　　　fmt.Printf("myvariable2Typ ist: :%T\n", myvariable2)
　　　　fmt.Printf("\nmyvariable3Wert ist: :%f\n", myvariable3)
　　　　fmt.Printf("myvariable3Typ ist: :%T\n", myvariable3)
}

Ausgabe:

myvariable1Wert ist: :　2
myvariable1Typ ist: :int
myvariable2Wert ist: : GFG
myvariable2Typ ist: :string
myvariable3Wert ist: :　67.560000
myvariable3der Typ ist: float64

Rückgabe mehrerer Werte durch Aufruf einer Funktion ermöglicht die Initialisierung einer Gruppe von Variablen.

Beispiel:

//Hier gibt die Funktion os.Open eine
//Variable i im Datei und ein Fehler
//im Variablen j
var i, j = os.Open(name)

（二）使用短变量声明：使用短变量声明um lokale Variablen zu deklarieren und zu initialisieren, die in der Funktion deklariert und initialisiert werden.

Syntax:

variable_name:= expression

Hinweis:Bitte verwenden Sie nicht in：=und=verwechselt werden, weil：= ist eine Deklaration, während = ist eine Zuweisung.

Wichtig:

In der obigen Ausdrucksform wird der Typ der Variable durch den Typ des Ausdrucks bestimmt.

package main
import "fmt"
func main() {
　　　　//　Verwende kurze Variablendeklarationen
　　　　myvariable1　:=　39
　　　　myvariable2　:= "oldtoolbag.com"
　　　　myvariable3　:=　34.67
　　　　//　Drucke den Wert und den Typ der Variable aus
　　　　fmt.Printf("myvariable1Wert ist: :%d\n", myvariable1)
　　　　fmt.Printf("myvariable1Typ ist: :%T\n", myvariable1)
　　　　fmt.Printf("\nmyvariable2Wert ist: :%s\n", myvariable2)
　　　　fmt.Printf("myvariable2Typ ist: :%T\n", myvariable2)
　　　　fmt.Printf("\nmyvariable3Wert ist: :%f\n", myvariable3)
　　　　fmt.Printf("myvariable3Typ ist: :%T\n", myvariable3)
}

Ausgabe:

myvariable1Wert ist: :　39
myvariable1Typ ist: :int
myvariable2Wert ist: :oldtoolbag.com
myvariable2Typ ist: :string
myvariable3Wert ist: :　34.670000
myvariable3der Typ ist: float64

Aufgrund ihrer Kompaktheit und Flexibilität werden die meisten lokalen Variablen mit kurzen Variablendeklarationen deklariert und initialisiert.

Die Variablendeklaration mit var wird für lokale Variablen verwendet, die eine explizite Typbezeichnung benötigen, die sich von der Ausdrucksbedingung unterscheidet, oder für Variablen, deren Wert später zugewiesen wird und deren Initialwert nicht wichtig ist.

Kurze Variablendeklarationen ermöglichen die Deklaration mehrerer Variablen in einer einzigen Deklaration.

package main
import "fmt"
func main() {
　　　　//Deklaration und Initialisierung von Variablen in einer Zeile
　　　　//Verwende kurze Variablendeklarationen
　　　　//Mehrere gleiche Typen von Variablen
　　　　myvariable1, myvariable2, myvariable3　:=　800,　34.7,　56.9
　　　　//　Drucke den Wert und den Typ der Variable aus
　　　　fmt.Printf("myvariable1Wert ist: :%d\n", myvariable1)
　　　　fmt.Printf("myvariable1Typ ist: :%T\n", myvariable1)
　　　　fmt.Printf("\nmyvariable2Wert ist: :%f\n", myvariable2)
　　　　fmt.Printf("myvariable2Typ ist: :%T\n", myvariable2)
　　　　fmt.Printf("\nmyvariable3Wert ist: :%f\n", myvariable3)
　　　　fmt.Printf("myvariable3Typ ist: :%T\n", myvariable3)
}

Ausgabe:

myvariable1Wert ist: :　800
myvariable1Typ ist: :int
myvariable2Wert ist: :　34.700000
myvariable2der Typ ist: float64
myvariable3Wert ist: :　56.900000
myvariable3der Typ ist: float64

In kurzen Variablendeklarationen ist es erlaubt, durch Aufrufe von Funktionen, die mehrere Werte zurückgeben, eine Gruppe von Variablen zu initialisieren.

//Hier gibt die Funktion os.Open eine
//Variable i im Datei und ein Fehler
//im Variablen j
i, j := os.Open(name)

Kurze Variablendeklarationen wirken sich nur auf Variablen aus, die bereits im selben Syntaxblock deklariert wurden, ähnlich wie eine Zuweisung. Variablen, die in externen Blöcken deklariert wurden, werden ignoriert. Wie im folgenden Beispiel gezeigt wird, ist mindestens eine dieser Variablen eine neue Variable.

package main
import "fmt"
func main() {
　　　　//Verwende kurze Variablendeklarationen
　　　　//Hier, die kurze Variablendeklaration
　　　　//als myvar2Wertzuweisung der Variablen
　　　　//Weil der gleiche Variable im selben Block existiert
　　　　//Daher myvar2Wert von45Ändere in100
　　　　myvar1, myvar2　:=　39,　45
　　　　myvar3, myvar2　:=　45,　100
　　　　//Wenn du eine Zeile mit Anmerkung ausführen möchtest,
　　　　//Dann gibt der Compiler einen Fehler, weil
　　　　//Diese Variablen sind bereits definiert, z.B.
　　　　//　myvar1，myvar2：=　43，47
　　　　//　myvar2：=　200
　　　　//　Drucke den Wert der Variable aus
　　　　fmt.Printf("myvar1　und myvar2　Wert: :%d %d\n", myvar1, myvar2)
　　　　fmt.Printf("myvar3　und myvar2　Wert: :%d %d\n", myvar3, myvar2)
}

Ausgabe:

myvar1　und myvar2　Wert:　39　100
myvar3　und myvar2　Wert:　45　100

Kurze Variablendeklarationen ermöglichen die Deklaration mehrerer Variablen desselben Typs in einer einzigen Deklaration. Der Typ der Variablen wird durch den Ausdruck bestimmt.

package main
import "fmt"
func main() {
　　　　//Deklaration und Initialisierung in einer Zeile
　　　　//Verwende kurze Variablendeklarationen
　　　　//Mehrere verschiedene Typen von Variablen
　　　　myvariable1, myvariable2, myvariable3　:=　800, "w3codebox",　47.56
　　　　//　Drucke den Wert und den Typ der Variable aus
　　　　fmt.Printf("myvariable1Wert ist: :%d\n", myvariable1)
　　　　fmt.Printf("myvariable1Typ ist: :%T\n", myvariable1)
　　　　fmt.Printf("\nmyvariable2Wert ist: :%s\n", myvariable2)
　　　　fmt.Printf("myvariable2Typ ist: :%T\n", myvariable2)
　　　　fmt.Printf("\nmyvariable3Wert ist: :%f\n", myvariable3)
　　　　fmt.Printf("myvariable3Typ ist: :%T\n", myvariable3)
}

Ausgabe:

myvariable1Wert ist: :　800
myvariable1Typ ist: :int
myvariable2Wert ist: :w3codebox
myvariable2Typ ist: :string
myvariable3Wert ist: :　47.560000
myvariable3der Typ ist: float64