Variablen & Datentypen in Go

Go ist statisch typisiert, aber dank Typ-Inferenz fuehlt es sich oft wie eine dynamische Sprache an. Schauen wir uns an, wie das geht.

Variablen deklarieren

Go kennt drei Formen:

1. Mit var und explizitem Typ

var name string = "Anna"
var alter int = 28

2. Mit var und Typ-Inferenz

var name = "Anna"   // string
var alter = 28      // int

3. Kurzform mit :=

Nur innerhalb von Funktionen:

name := "Anna"
alter := 28

Die Kurzform ist die haeufigste Variante im Go-Alltag.

Mehrere Variablen auf einmal

var (
    name  = "Anna"
    alter = 28
    aktiv = true
)

// oder auf einer Zeile
a, b, c := 1, 2, 3

Zero Values

Wichtig: In Go gibt es keine “undefiniert”-Zustaende. Jeder Typ hat einen Zero Value:

Typ	Zero Value
int	0
float64	0.0
bool	false
string	""
Pointer	nil
Slice/Map	nil

var x int
fmt.Println(x) // 0 - kein Crash, kein "undefined"

Konstanten

const fuer Werte, die sich nie aendern:

const Pi = 3.14159
const MaxRetries = 5
const (
    StatusOK    = 200
    StatusError = 500
)

Konstanten gibt es nur fuer primitive Typen - keine Slices, Maps oder Structs.

Die eingebauten Typen

Zahlen

var a int     = 42          // systemabhaengig (32 oder 64 Bit)
var b int32   = 42
var c int64   = 42
var d uint    = 42          // vorzeichenlos
var e float64 = 3.14        // Default fuer Dezimalzahlen
var f float32 = 3.14

Im Alltag nimmst du meistens int und float64.

Strings

name := "Anna"               // UTF-8 kodiert
laenge := len(name)          // 4 (in Bytes, nicht in Zeichen!)
teil   := name[0:2]          // "An"

Strings sind unveraenderlich. Verkettung:

gruss := "Hallo, " + name

Fuer groessere Aufgaben ist strings.Builder effizienter:

import "strings"

var sb strings.Builder
sb.WriteString("Hallo, ")
sb.WriteString(name)
ergebnis := sb.String()

Booleans

var aktiv bool = true
fertig := false

Runes & Characters

Ein rune ist ein Unicode-Codepunkt (ein int32 im Hintergrund):

buchstabe := 'A'        // rune, Wert 65
emoji     := '🐹'       // rune, eine einzige Code-Einheit

Typ-Konvertierung

Go macht keine impliziten Konvertierungen:

var a int = 5
var b float64 = float64(a) // explizit!

// Ins Ausgangstyp zurueck
var c int = int(b)

Zu String und zurueck

Nutze das strconv-Paket:

import "strconv"

s := strconv.Itoa(42)           // "42"
n, err := strconv.Atoi("42")    // n=42, err=nil

f := strconv.FormatFloat(3.14, 'f', 2, 64)  // "3.14"

Composite Types (kurzer Vorblick)

Die wichtigsten kennst du noch nicht im Detail - hier nur eine Vorschau:

Arrays (selten genutzt)

Feste Groesse:

var zahlen [3]int = [3]int{1, 2, 3}

Slices (der Standard)

Dynamisch groessenveraenderlich:

namen := []string{"Max", "Anna", "Leo"}
namen = append(namen, "Tim")

Maps

Key-Value-Paare:

alter := map[string]int{
    "Anna": 28,
    "Max":  34,
}
fmt.Println(alter["Anna"]) // 28

Structs

Eigene Datentypen:

type Person struct {
    Name  string
    Alter int
}

p := Person{Name: "Anna", Alter: 28}

Slices, Maps und Structs behandeln wir in spaeteren Kapiteln ausfuehrlicher.

Die Konvention: camelCase

• Variablen: nutzerName, maxCount
• Konstanten: maxRetries, DefaultPort
• Exportierte (oeffentliche) Namen beginnen mit Grossbuchstaben: Person, Name. Das ist Go’s Zugriffskontrolle - keine public/private-Schluesselwoerter noetig.

Zusammenfassung

• Drei Arten Variablen zu deklarieren: var ... Typ, var ..., :=
• Alles hat einen Zero Value - keine undefined/null-Chaos
• const fuer konstante Werte
• Typ-Konvertierung ist explizit (float64(x))
• Grossbuchstaben-Namen sind exportiert

Im naechsten Kapitel: Kontrollstrukturen wie if und Schleifen.