Go-Variablen

Variablen sind benannte Speicherbereiche im Speicher. In Go werden Variablen mit dem var-Schlüsselwort deklariert.

Deklaration

Variablen werden mit dem var-Schlüsselwort deklariert.

var name string

Dies deklariert eine Variable namens name vom Typ string.

Initialisierung

Variablen können bei der Deklaration initialisiert werden.

var name string = "Alice"

Der Typ kann weggelassen werden, wenn ein Wert zugewiesen wird.

var name = "Alice"

Kurzdeklaration

Innerhalb von Funktionen kann die Kurzdeklaration := verwendet werden.

name := "Alice"
age := 25

TIP

Die Kurzdeklaration kann nur innerhalb von Funktionen verwendet werden.

Mehrfachdeklaration

Mehrere Variablen können gleichzeitig deklariert werden.

var a, b, c int = 1, 2, 3

Oder ohne Typangabe.

var a, b, c = 1, 2, 3

Oder mit Kurzdeklaration.

a, b, c := 1, 2, 3

Typinferenz

Go kann den Typ einer Variable aus dem zugewiesenen Wert ableiten.

var name = "Alice"  // string
var age = 25        // int
var pi = 3.14       // float64
var isActive = true // bool

Nullwert

Variablen, die nicht initialisiert werden, erhalten einen Nullwert.

Typ	Nullwert
int	0
float64	0.0
string	""
bool	false
Zeiger	nil
Slice	nil
Map	nil
Kanal	nil
Funktion	nil
Schnittstelle	nil

var n int
fmt.Println(n) // 0

var s string
fmt.Println(s) // ""

var b bool
fmt.Println(b) // false

Gültigkeitsbereich

Variablen haben einen Gültigkeitsbereich, in dem sie verwendet werden können.

var globalVar = "global" // Paketebene

func main() {
   var localVar = "lokal" // Funktionsebene
   if true {
      var blockVar = "block" // Blockebene
      fmt.Println(blockVar)
   }
   // fmt.Println(blockVar) // Fehler: blockVar ist nicht definiert
}

Exportierte Variablen

Variablen, die mit einem Großbuchstaben beginnen, sind exportiert und können von anderen Paketen verwendet werden.

package main

var ExportedVar = "exportiert" // exportiert
var unexportedVar = "nicht exportiert" // nicht exportiert

Konstanten

Konstanten sind Variablen, deren Wert nicht geändert werden kann.

const Pi = 3.14159
const E = 2.71828

Siehe Konstanten für weitere Details.

iota

iota ist ein spezieller Identifizierer, der in Konstantendeklarationen verwendet wird.

const (
   A = iota // 0
   B        // 1
   C        // 2
)

Siehe Konstanten für weitere Details.

Variablen und Zeiger

Variablen können als Zeiger verwendet werden.

a := 42
p := &a
fmt.Println(*p) // 42
*p = 100
fmt.Println(a) // 100

Siehe Zeiger für weitere Details.

Variablen und Slices

Slices sind Referenztypen.

s := []int{1, 2, 3}
s[0] = 100
fmt.Println(s) // [100 2 3]

Siehe Slice für weitere Details.

Variablen und Maps

Maps sind Referenztypen.

m := map[string]int{"a": 1}
m["a"] = 100
fmt.Println(m) // map[a:100]

Siehe Map für weitere Details.

Variablen und Strukturen

Strukturen sind Werttypen, können aber als Zeiger verwendet werden.

type Person struct {
   Name string
   Age  int
}

p := Person{Name: "Alice", Age: 25}
p.Age = 26

pp := &Person{Name: "Bob", Age: 30}
pp.Age = 31

Siehe Struktur für weitere Details.