Hoe declareer je variabelen en wat zijn Go's basistypen?

Question

Accepted Answer

Go is statically getypeerd met verschillende manieren om variabelen te declareren. De meest voorkomende is de **short declaration** `:=`, die het type afleidt. Go's basistypen omvatten nummers, strings, booleans en meer.

## Variabelen declareren

```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)
```

`:=` is de idiomatische manier in functies — beknopt met type inference. `var` wordt gebruikt op pakketniveau en wanneer je een expliciet type wilt of alleen de zero value.

## De basistypen

```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
```

## Zero values — geen "ongeïnitialiseerde" variabelen

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

Een cruciaal Go-kenmerk: elke gedeclareerde variabele krijgt automatisch een verstandige **zero value** — er zijn geen ongedefinieerde/garbage values. Dit maakt code veiliger en betekent dat je vaak expliciete initialisatie kunt overslaan.

## Type conversions zijn expliciet

```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 vereist **expliciete** type conversions — het mengt nooit impliciet typen, wat een klasse van subtiele bugs voorkomt.

## Waarom het belangrijk is

De variabelendeclaraties en typen van Go begrijpen is fundamenteel voor het schrijven van Go-code.

De idiomatische `:=` short declaration met inference houdt code beknopt, terwijl `var` en constants hun rol vervullen.

De **zero-value guarantee** (elke variabele is veilig geïnitialiseerd) is een onderscheidend, belangrijk Go-kenmerk dat bugs met ongeïnitialiseerde variabelen elimineert en idiomatische patronen vormt (bijvoorbeeld een zero-valued struct is vaak bruikbaar).

En Go's insistentie op **expliciete type conversions** (geen impliciete coërcie) is een bewuste veiligheidskeuze die soorten stille numeric bugs voorkomt die andere talen toestaan.

De basistypen kennen (vooral `rune` voor Unicode, `byte`, en dat `int`/`float64` de standaardinstellingen zijn) is essentiële dagelijkse kennis.