Jak deklarujete proměnné a jaké jsou základní typy v Go?

Question

Accepted Answer

Go je staticky typovaný jazyk s několika způsoby deklarace proměnných. Nejběžnější je **krátká deklarace** `:=`, která odvodí typ. Základní typy v Go pokrývají čísla, řetězce, logické hodnoty a další.

## Deklarace proměnných

```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 idiomatický způsob v rámci funkce — stručný s odvozením typu. `var` se používá na úrovni balíčku a když chcete explicitní typ nebo jen nulovou hodnotu.

## Základní typy

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

## Nulové hodnoty — žádné "neinicializované" proměnné

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

Zásadní vlastnost Go: každá deklarovaná proměnná automaticky získá rozumnou **nulovou hodnotu** — neexistují žádné nedefinované/náhodné hodnoty. To činí kód bezpečnějším a znamená, že se často můžete vyhnout explicitní inicializaci.

## Konverze typů jsou explicitní

```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 vyžaduje **explicitní** konverze typů — nikdy nevylučuje typy implicitně, což předchází třídě jemných chyb.

## Proč je to důležité

Pochopení deklarací proměnných a typů v Go je základem pro psaní jakéhokoliv Go.

Idiomatická krátká deklarace `:=` s odvozením typu udržuje kód stručný, zatímco `var` a konstanty slouží svým účelům.

**Záruka nulové hodnoty** (každá proměnná je bezpečně inicializována) je výrazná a důležitá vlastnost Go, která eliminuje chyby neinicializovaných proměnných a formuje idiomatické vzory (např. nulová struktura je často použitelná).

A naléhání Go na **explicitní konverze typů** (žádná implicitní koerce) je záměrná volba bezpečnosti, která předchází druhům tichých numerických chyb, které ostatní jazyky umožňují.

Znalost základních typů (zejména `rune` pro Unicode, `byte` a že `int`/`float64` jsou výchozí) je základní každodenní znalost.