Wie deklarierst du Variablen und was sind Go's grundlegende Typen?

Question

Accepted Answer

Go ist statisch typisiert und bietet mehrere Möglichkeiten zur Variablendeklaration. Die gebräuchlichste ist die **Kurzform** `:=`, die den Typ ableitet. Go's grundlegende Typen umfassen Zahlen, Strings, Booleans und mehr.

## Variablendeklaration

```go
var x int = 42        // full form: explicit type and value
var y = 42            // type inferred → int
var z int             // declared, ZERO-valued (z = 0)

name := "Ann"         // short declaration (:=) — infers type, INSIDE functions only
count := 10

var a, b = 1, "two"   // multiple at once
const Pi = 3.14159     // constant (compile-time)
```

`:=` ist die idiomatische Methode innerhalb von Funktionen — prägnant mit Typableitung. `var` wird auf Paketebene verwendet und wenn du einen expliziten Typ möchtest oder nur den Nullwert.

## Die grundlegenden Typen

```go
// integers
int, int8, int16, int32, int64     // signed (int is platform-sized, usually 64-bit)
uint, uint8, ..., uint64           // unsigned
byte                                // alias for uint8
rune                                // alias for int32 — a Unicode code point

// floating point
float32, float64                    // float64 is the default for decimals

// others
string                              // immutable UTF-8 text
bool                               // true / false
complex64, complex128              // complex numbers
```

## Nullwerte — keine "uninitialisierten" Variablen

```go
var i int       // 0
var f float64   // 0.0
var s string    // "" (empty)
var b bool      // false
var p *int      // nil
```

Ein entscheidendes Go-Feature: Jede deklarierte Variable erhält automatisch einen sinnvollen **Nullwert** — es gibt keine undefinierten/zufälligen Werte. Das macht Code sicherer und bedeutet, dass du explizite Initialisierung oft überspringen kannst.

## Typkonvertierungen sind explizit

```go
var i int = 42
var f float64 = float64(i)   // MUST convert explicitly — no implicit coercion
var u uint = uint(f)
// i + f  → ❌ compile error: mismatched types
```

Go erfordert **explizite** Typkonvertierungen — es mischt niemals implizit Typen und verhindert damit eine Klasse subtiler Fehler.

## Warum es wichtig ist

Das Verständnis von Go's Variablendeklarationen und Typen ist grundlegend für das Schreiben von Go-Code.

Die idiomatische `:=` Kurzform mit Typableitung hält Code prägnant, während `var` und Konstanten ihre Rollen erfüllen.

Die **Nullwert-Garantie** (jede Variable ist sicher initialisiert) ist ein charakteristisches, wichtiges Go-Feature, das Fehler bei uninitialisierten Variablen eliminiert und idiomatische Muster prägt (z.B. eine Null-bewertete Struktur ist oft brauchbar).

Und Go's Insistieren auf **expliziten Typkonvertierungen** (keine implizite Umwandlung) ist eine bewusste Sicherheitsentscheidung, die die Art stiller numerischer Fehler verhindert, die andere Sprachen zulassen.

Die grundlegenden Typen zu kennen (besonders `rune` für Unicode, `byte` und dass `int`/`float64` die Standardvorgaben sind) ist essentielles Alltagswissen.