Kako deklarirате varijable i koja su Go-ova osnovna svojstva?

Question

Accepted Answer

Go je statički tipiziran s nekoliko načina za deklariranje varijabli. Najčešće je **short declaration** `:=`, koja zaključuje tip. Go-ova osnovna svojstva pokrivaju brojeve, stringove, boolean vrijednosti i više.

## Deklariranje varijabli

```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 u funkciji — koncizan s zaključivanjem tipa. `var` se koristi na razini paketa i kada želite eksplicitan tip ili samo nula vrijednost.

## Osnovna svojstva

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

## Nula vrijednosti — bez "neinicijaliziranih" varijabli

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

Odličan Go značaj: svaka deklarirana varijabla automatski dobiva razumnu **nula vrijednost** — nema nedefiniranih/nasumičnih vrijednosti. To čini kod sigurnijim i znači da često možete preskočiti eksplicitnu inicijalizaciju.

## Konverzije tipova su eksplicitne

```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 zahtijeva **eksplicitne** konverzije tipova — nikada implicitno ne miješa tipove, sprečavajući klasu suptilnih grešaka.

## Zašto je to važno

Razumijevanje Go-ovih deklaracija varijabli i svojstava je temeljno za pisanje bilo kojeg Go-a.

Idiomatska short declaration `:=` s zaključivanjem drži kod koncizan, dok `var` i konstante služe svoje svrhe.

**Nula vrijednost garancija** (svaka varijabla je sigurno inicijalizirana) je karakteristična, važna Go značajka koja eliminira greške neinicijaliziranih varijabli i oblikuje idiomatske obrasce (npr. nula vrijednost strukture često je upotrebljiva).

I Go-ovo inzistiranje na **eksplicitnim konverzijama tipova** (bez implicitne prisilne konverzije) je namjeran odabir sigurnosti koji sprječava vrste tihe numeričke greške koje dopuštaju drugi jezici.

Poznavanje osnovnih svojstava (posebno `rune` za Unicode, `byte`, i da su `int`/`float64` zadane vrijednosti) je essencijalno svakodnevno znanje.