Hvordan deklarerer du variabler og hva er Gos grunnleggende typer?

Question

Accepted Answer

Go er statisk typet med flere måter å deklarere variabler. Den vanligste er **kort deklarasjon** `:=`, som utleder typen. Gos grunnleggende typer dekker tall, strenger, boolske verdier og mer.

## Deklarering av 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åten å deklarere inni funksjoner — presis med typeutledning. `var` brukes på pakkenivå og når du vil ha en eksplisitt type eller bare nullverdien.

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

## Nullverdier — ingen "uinitialiserte" variabler

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

En avgjørende Go-funksjon: hver deklarert variabel får automatisk en fornuftig **nullverdi** — det finnes ingen udefinerte/søppelverdier. Dette gjør koden tryggere og betyr at du ofte kan hoppe over eksplisitt initialisering.

## Typekonverteringer er eksplisitte

```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 krever **eksplisitte** typekonverteringer — det blander aldri implisitt typer, noe som forhindrer en klasse av subtile bugs.

## Hvorfor det betyr noe

Å forstå Gos variabeldeklarasjoner og typer er grunnleggende for å skrive Go.

Den idiomatiske `:=` kort deklarasjon med utledning holder koden presis, mens `var` og konstanter tjener sine roller.

**Nullverdi-garantien** (hver variabel er trygt initialisert) er en karakteristisk, viktig Go-funksjon som eliminerer bugs med uinitialiserte variabler og former idiomatiske mønstre (f.eks. en nullverdi-struct er ofte brukbar).

Og Gos insistering på **eksplisitte typekonverteringer** (ingen implisitt tvangskonvertering) er et bevisst sikkerheitsvalg som forhindrer de slags stille numeriske bugs som andre språk tillater.

Å kjenne grunnleggende typer (spesielt `rune` for Unicode, `byte`, og at `int`/`float64` er standardene) er essensiell hverdagskunnskap.