Zero value e conversioni di tipo

In Go ogni variabile dichiarata senza un valore esplicito riceve uno zero value: il "valore neutro" del suo tipo. È una differenza enorme rispetto a JavaScript, dove let x; produce undefined, o C, dove ti ritrovi con memoria spazzatura. Niente undefined, niente UB: solo zero.

La tabella degli zero value

var i int        // 0
var f float64    // 0
var s string     // ""
var b bool       // false
var p *int       // nil
var nums []int   // nil  (NB: una slice nil ha len 0 e si può iterare!)

Le conversioni sono SEMPRE esplicite

Diversamente da C, Python o JS, Go non promuove automaticamente un numerico a un altro: bisogna scrivere tipo(valore).

i := 42
var f float64 = float64(i)
var u uint = uint(i)

Questo vale anche per tipi "compatibili" come int e int64: serve sempre la conversione esplicita.

var a int = 10
var b int64 = int64(a)  // obbligatorio

Conversione tra numerici: attenzione alla troncatura

Passare da float64 a int tronca verso zero, non arrotonda:

f := 3.9
i := int(f)   // 3, non 4
n := int(-3.9) // -3, non -4

Conversione stringa ↔ numeri

string(65) NON dà "65": dà "A" (il rune con code point 65). Per stringa → numero e viceversa serve il pacchetto strconv:

import "strconv"

s := strconv.Itoa(42)        // "42"
n, err := strconv.Atoi("42") // 42, nil

Lo vedremo a fondo nel modulo Stdlib.

Prova tu

f := 3.7
fmt.Println(int(f))

Recap

• Ogni tipo ha uno zero value coerente: niente undefined, niente UB.
• Slice/map/chan/func/interface/pointer hanno zero value nil.
• Le conversioni numeriche sono sempre esplicite con tipo(valore).
• int(float) tronca verso zero; per arrotondare usa math.Round.
• Per stringa ↔ numero usa il pacchetto strconv (NON il cast diretto).