Jak deklaruje się zmienne i jakie są podstawowe typy w Go?

Question

Accepted Answer

Go jest statycznie typowany i oferuje kilka sposobów deklaracji zmiennych. Najczęściej używana jest **krótka deklaracja** `:=`, która automatycznie wnioskuje typ. Podstawowe typy Go obejmują liczby, stringi, wartości logiczne i wiele więcej.

## Deklarowanie zmiennych

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

`:=` jest idiomatycznym sposobem wewnątrz funkcji — zwięzły z wnioskowaniem typu. `var` jest używany na poziomie pakietu oraz gdy chcesz jawnie określić typ lub po prostu wartość zerową.

## Typy podstawowe

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

## Wartości zerowe — brak "niezainicjalizowanych" zmiennych

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

Kluczowa cecha Go: każda zdeklarowana zmienna automatycznie otrzymuje rozsądną **wartość zerową** — nie ma niezdefiniowanych/losowych wartości. To czyni kod bezpieczniejszym i oznacza, że często możesz pominąć jawną inicjalizację.

## Konwersje typów są jawne

```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 wymaga **jawnych** konwersji typów — nigdy nie mieszają typów niejawnie, zapobiegając klasie subtelnych błędów.

## Dlaczego to ważne

Zrozumienie deklaracji zmiennych i typów w Go jest fundamentalne dla pisania jakiegokolwiek kodu w Go.

Idiomatyczna krótka deklaracja `:=` z wnioskowaniem typu utrzymuje kod zwięzły, podczas gdy `var` i stałe pełnią swoje role.

**Gwarancja wartości zerowej** (każda zmienna jest bezpiecznie zainicjalizowana) jest charakterystyczną, ważną cechą Go, która eliminuje błędy niezainicjalizowanych zmiennych i kształtuje idiomatyczne wzorce (np. struktura z wartością zerową jest często używalna).

I naleganie Go na **jawne konwersje typów** (brak niejawnej koercji) to celowy wybór bezpieczeństwa, który zapobiega rodzajom cichych błędów numerycznych, które pozwalają inne języki.

Znajomość typów podstawowych (szczególnie `rune` dla Unicode, `byte` i fakt, że `int`/`float64` są wartościami domyślnymi) jest niezbędną codzienną wiedzą.