Hur deklarerar du variabler och vilka är Gos grundläggande typer?

Question

Accepted Answer

Go är statiskt typat med flera sätt att deklarera variabler. Det vanligaste är **kort deklaration** `:=`, som härledde typen. Gos grundläggande typer omfattar tal, strängar, booleska värden och mer.

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

`:=` är det idiomatiska sättet in-funktion — präcist med typöverslutning. `var` används på paketnivå och när du vill ha en explicit typ eller bara nollvärdet.

## De grundläggande typerna

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

## Nollvärden — inga "initierade" variabler

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

En avgörande Go-funktion: varje deklarerad variabel får ett vettigt **nollvärde** automatiskt — det finns inga odefinierade/skräpvärden. Detta gör koden säkrare och innebär att du ofta kan hoppa över explicit initialisering.

## Typkonverteringar är explicita

```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 **explicita** typkonverteringar — det blandar aldrig implicit typer, vilket förhindrar en klass av subtila buggar.

## Varför det spelar roll

Att förstå Gos variabeldeklarationer och typer är grundläggande för att skriva någon Go.

Den idiomatiska `:=`-kort deklarationen med överslutning håller koden präcis, medan `var` och konstanter fyller sina roller.

**Nollvärdegranten** (varje variabel är säkert initialiserad) är en särskiljande, viktig Go-funktion som eliminerar buggar med initierade variabler och formar idiomatiska mönster (t.ex. en nollvärderad struct är ofta användbar).

Och Gos insisterande på **explicita typkonverteringar** (ingen implicit tvingning) är ett avsiktligt säkerhetskvalität som förhindrar den typ av tysta numeriska buggar andra språk tillåter.

Att känna till de grundläggande typerna (särskilt `rune` för Unicode, `byte`, och att `int`/`float64` är standarden) är väsentlig daglig kunskap.