Hvordan erklærer du variabler og hvad er Go's grundlæggende typer?

Question

Accepted Answer

Go er statisk typet med flere måder at erklære variabler på. Den mest almindelige er **kort erklæring** `:=`, som udleder typen. Go's grundlæggende typer dækker tal, strenge, boolske værdier og mere.

## Erklæring af variabler

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

`:=` er den idiomatiske måde inden for funktioner — kortfattet med typeinference. `var` bruges på pakkeniveau og når du ønsker en eksplicit type eller blot nulværdien.

## De grundlæggende typer

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

## Nulværdier — ingen "uinitialiserede" variabler

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

En afgørende Go-feature: hver deklareret variabel får automatisk en fornuftig **nulværdi** — der er ingen udefinerede/tilfældige værdier. Dette gør kode mere sikker og betyder, at du ofte kan springe eksplicit initialisering over.

## Typekonverteringer er eksplicitte

```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 kræver **eksplicitte** typekonverteringer — det blander aldrig typer implicit og forhindrer en klasse af subtile fejl.

## Hvorfor det betyder noget

At forstå Go's variabelerklæringer og typer er grundlæggende for at skrive al Go-kode.

Den idiomatiske `:=` korterklæring med inference holder kode kortfattet, mens `var` og konstanter tjener deres formål.

**Nulværdi-garantien** (hver variabel er sikkert initialiseret) er en karakteristisk, vigtig Go-feature, der eliminerer uinitialiseret-variabel-fejl og former idiomatiske mønstre (f.eks. en nul-værdies struktur er ofte brugbar).

Og Go's insisteren på **eksplicitte typekonverteringer** (ingen implicit tvang) er et bevidst sikkerhedsvalg, der forhindrer de slags stille numeriske fejl, som andre sprog tillader.

At kende de grundlæggende typer (især `rune` til Unicode, `byte` og at `int`/`float64` er standardtyper) er daglig vigtig viden.