Come si dichiarano le variabili e quali sono i tipi base di Go?

Question

Accepted Answer

Go è tipizzato staticamente con diversi modi per dichiarare variabili. Il più comune è la **short declaration** `:=`, che inferisce il tipo. I tipi base di Go coprono numeri, stringhe, booleani e altro.

## Dichiarare variabili

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

`:=` è il modo idiomatico dentro una funzione — conciso con inferenza di tipo. `var` viene usato a livello di pacchetto e quando si vuole un tipo esplicito o solo il valore zero.

## I tipi base

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

## Valori zero — niente variabili "non inizializzate"

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

Una caratteristica cruciale di Go: ogni variabile dichiarata riceve automaticamente un **valore zero** sensato — non esistono valori non definiti/casuali. Questo rende il codice più sicuro e significa che spesso puoi saltare l'inizializzazione esplicita.

## Le conversioni di tipo sono esplicite

```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 richiede conversioni di tipo **esplicite** — non mescola mai implicitamente i tipi, prevenendo una classe di bug sottili.

## Perché è importante

Comprendere le dichiarazioni di variabili e i tipi di Go è fondamentale per scrivere qualsiasi codice Go.

La short declaration idiomatica `:=` con inferenza mantiene il codice conciso, mentre `var` e le costanti svolgono i loro ruoli.

La **garanzia del valore zero** (ogni variabile è inizializzata in modo sicuro) è una caratteristica distintiva e importante di Go che elimina i bug da variabili non inizializzate e plasma i pattern idiomatici (ad es. uno struct a valore zero è spesso utilizzabile).

E l'insistenza di Go sulle **conversioni di tipo esplicite** (nessuna coercizione implicita) è una scelta di sicurezza deliberata che previene i tipi di bug numerici silenziosi che altri linguaggi permettono.

Conoscere i tipi base (in particolare `rune` per Unicode, `byte`, e che `int`/`float64` sono i predefiniti) è una conoscenza essenziale quotidiana.