Kako deklariraš spremenljivke in katere so osnovni tipi v Go?

Question

Accepted Answer

Go je statično tipiziran jezik z več načini za deklariranje spremenljivk. Najbolj pogost je **kratka deklaracija** `:=`, ki avtomatsko sklepa tip. Osnovni tipi v Go pokrivajo števila, nize, logične vrednosti in več.

## Deklariranje spremenljivk

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

`:=` je idiomatski način v funkcijah — jedrnat s sklepanjem tipa. `var` se uporablja na ravni paketa in ko želiš eksplicitni tip ali samo ničelno vrednost.

## Osnovni tipi

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

## Ničelne vrednosti — ni "neinicializiranih" spremenljivk

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

Osnovalna značilnost Go: vsaka deklarirana spremenljivka dobi smiselno **ničelno vrednost** samodejno — ni nedefiniranih/naključnih vrednosti. To naredi kodo varnejšo in pomeni, da lahko pogosto preskočiš eksplicitno inicializacijo.

## Pretvarjanje tipov je eksplicitno

```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 zahteva **eksplicitne** pretvarjave tipov — nikoli ne meša tipov implicitno, kar preprečuje razred subtilnih napak.

## Zakaj je to pomembno

Razumevanje Go deklaracij spremenljivk in tipov je temeljno za pisanje kateregakoli Go.

Idiomatska `:=` kratka deklaracija s sklepanjem tipov drži kodo jedrnato, medtem ko `var` in konstante služijo svojim namenom.

**Zagotovilo ničelne vrednosti** (vsaka spremenljivka je varno inicializirana) je značilna, pomembna Go značilnost, ki izključuje napake neinicializiranih spremenljivk in oblikuje idiomatske vzorce (na primer nič-vrednostna struktura je pogosto uporabna).

In Go-ova vztrajnost na **eksplicitnih pretvarjavah tipov** (brez implicitne prisile) je premišljena varnostna odločitev, ki preprečuje vrste neslenih številčnih napak, ki jih dovoljujejo drugi jeziki.

Znanje osnovnih tipov (posebej `rune` za Unicode, `byte` in da so `int`/`float64` privzeti) je bistveno vsakodnevno znanje.