Go - Variablen

Eine Variable ist nichts anderes als ein Name für einen Speicherbereich, den die Programme bearbeiten können. Jede Variable in Go hat einen bestimmten Typ, der die Größe und das Layout des Speichers der Variablen, den Wertebereich, der in diesem Speicher gespeichert werden kann, und den Satz von Operationen bestimmt, die auf die Variable angewendet werden können.

Der Name einer Variablen kann aus Buchstaben, Ziffern und dem Unterstrich bestehen. Es muss entweder mit einem Buchstaben oder einem Unterstrich beginnen. Groß- und Kleinbuchstaben unterscheiden sich, da bei Go zwischen Groß- und Kleinschreibung unterschieden wird. Basierend auf den im vorherigen Kapitel erläuterten Grundtypen gibt es die folgenden Grundvariablentypen:

Sr.Nr.	Typ & Beschreibung
1	byte Normalerweise ein einzelnes Oktett (ein Byte). Dies ist ein Bytetyp.
2	int Die natürlichste Ganzzahlgröße für die Maschine.
3	float32 Ein Gleitkommawert mit einfacher Genauigkeit.

Mit der Programmiersprache Go können Sie auch verschiedene andere Variablentypen wie Aufzählung, Zeiger, Array, Struktur und Union definieren, die in den folgenden Kapiteln erläutert werden. In diesem Kapitel konzentrieren wir uns nur auf grundlegende Variablentypen.

Variablendefinition in Go

Eine Variablendefinition teilt dem Compiler mit, wo und wie viel Speicher für die Variable erstellt werden soll. Eine Variablendefinition gibt einen Datentyp an und enthält eine Liste einer oder mehrerer Variablen dieses Typs wie folgt:

var variable_list optional_data_type;

Hier, optional_data_type ist ein gültiger Go-Datentyp, einschließlich Byte, Int, Float32, Complex64, Boolean oder eines benutzerdefinierten Objekts usw., und variable_listkann aus einem oder mehreren durch Kommas getrennten Bezeichnernamen bestehen. Einige gültige Erklärungen werden hier angezeigt -

var  i, j, k int;
var  c, ch byte;
var  f, salary float32;
d =  42;

Die Aussage “var i, j, k;”deklariert und definiert die Variablen i, j und k; Dies weist den Compiler an, Variablen mit den Namen i, j und k vom Typ int zu erstellen.

Variablen können in ihrer Deklaration initialisiert (mit einem Anfangswert versehen) werden. Der Variablentyp wird vom Compiler automatisch anhand des an ihn übergebenen Werts beurteilt. Der Initialisierer besteht aus einem Gleichheitszeichen, gefolgt von einem konstanten Ausdruck wie folgt:

variable_name = value;

Zum Beispiel,

d = 3, f = 5;    // declaration of d and f. Here d and f are int

Für die Definition ohne Initialisierer: Variablen mit statischer Speicherdauer werden implizit mit nil initialisiert (alle Bytes haben den Wert 0). Der Anfangswert aller anderen Variablen ist der Nullwert ihres Datentyps.

Statische Typdeklaration in Go

Eine statische Typvariablendeklaration bietet dem Compiler die Gewissheit, dass eine Variable mit dem angegebenen Typ und Namen verfügbar ist, sodass der Compiler mit der weiteren Kompilierung fortfahren kann, ohne die vollständigen Details der Variablen zu benötigen. Eine Variablendeklaration hat nur zum Zeitpunkt der Kompilierung ihre Bedeutung, der Compiler benötigt die eigentliche Variablendeklaration zum Zeitpunkt der Verknüpfung des Programms.

Beispiel

Versuchen Sie das folgende Beispiel, in dem die Variable mit einem Typ deklariert und innerhalb der Hauptfunktion initialisiert wurde:

package main

import "fmt"

func main() {
   var x float64
   x = 20.0
   fmt.Println(x)
   fmt.Printf("x is of type %T\n", x)
}

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

20
x is of type float64

Dynamische Typdeklaration / Typinferenz in Go

Bei einer dynamischen Typvariablendeklaration muss der Compiler den Typ der Variablen basierend auf dem an sie übergebenen Wert interpretieren. Der Compiler benötigt keine Variable, um einen statischen Typ als notwendige Anforderung zu haben.

Beispiel

Versuchen Sie das folgende Beispiel, in dem die Variablen ohne Typ deklariert wurden. Beachten Sie, dass wir im Falle einer Typinferenz die Variable initialisiert habeny mit: = Operator, während x wird mit dem Operator = initialisiert.

package main

import "fmt"

func main() {
   var x float64 = 20.0

   y := 42 
   fmt.Println(x)
   fmt.Println(y)
   fmt.Printf("x is of type %T\n", x)
   fmt.Printf("y is of type %T\n", y)	
}

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

20
42
x is of type float64
y is of type int

Gemischte Variablendeklaration in Go

Variablen verschiedener Typen können mithilfe der Typinferenz auf einmal deklariert werden.

Beispiel

package main

import "fmt"

func main() {
   var a, b, c = 3, 4, "foo"  
	
   fmt.Println(a)
   fmt.Println(b)
   fmt.Println(c)
   fmt.Printf("a is of type %T\n", a)
   fmt.Printf("b is of type %T\n", b)
   fmt.Printf("c is of type %T\n", c)
}

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

3
4
foo
a is of type int
b is of type int
c is of type string

Die lWerte und die rWerte in Go

Es gibt zwei Arten von Ausdrücken in Go -

lvalue- Ausdrücke, die sich auf einen Speicherort beziehen, werden als "lvalue" -Ausdruck bezeichnet. Ein l-Wert kann entweder als linke oder rechte Seite einer Zuweisung angezeigt werden.
rvalue- Der Begriff rWert bezieht sich auf einen Datenwert, der an einer bestimmten Adresse im Speicher gespeichert ist. Ein r-Wert ist ein Ausdruck, dem kein Wert zugewiesen werden kann. Dies bedeutet, dass ein r-Wert möglicherweise auf der rechten, aber nicht auf der linken Seite einer Zuweisung angezeigt wird.

Variablen sind l-Werte und können daher auf der linken Seite einer Zuweisung angezeigt werden. Numerische Literale sind r-Werte und können daher nicht zugewiesen werden und nicht auf der linken Seite angezeigt werden.

Die folgende Aussage ist gültig -

x = 20.0

Die folgende Aussage ist ungültig. Es würde einen Fehler bei der Kompilierung erzeugen -

10 = 20