Operatori

Go ha gli operatori classici che ti aspetti, con poche sorprese: aritmetici, di confronto, logici, bitwise. Niente operatore ternario (a ? b : c), niente overloading, niente conversioni implicite tra tipi. La semplicità è una feature.

Aritmetici

a, b := 10, 3
fmt.Println(a + b)  // 13
fmt.Println(a - b)  // 7
fmt.Println(a * b)  // 30
fmt.Println(a / b)  // 3   ← divisione INTERA tra interi
fmt.Println(a % b)  // 1   ← resto (modulo)

Incremento e decremento sono STATEMENT, non espressioni

x++ e x-- non producono un valore: sono "azioni" e basta. Niente y := x++ come in C.

x := 5
x++          // ok: incrementa x
// y := x++  // ERRORE di compilazione
fmt.Println(x) // 6

Confronto

== != < <= > >= ritornano bool. Si applicano a numeri e stringhe; per gli struct serve che TUTTI i campi siano confrontabili (niente slice/map dentro).

"abc" == "abc"  // true
"abc" < "abd"   // true (ordine lessicografico)
3 != 4           // true

Logici con cortocircuito

&&, ||, !. Cortocircuitano da sinistra a destra: se il primo operando basta a determinare il risultato, il secondo non viene neanche valutato.

adult := age >= 18
seniorAdult := age >= 18 && age < 65

Bitwise

& AND, | OR, ^ XOR, << shift sinistro, >> shift destro, &^ AND NOT (bit clear). Sono utili per flag, parsing binario e ottimizzazioni:

flags := uint8(0b0000_0011)
flags |= 0b0000_0100   // imposta un bit:    0000_0111
flags &^= 0b0000_0010  // cancella un bit:   0000_0101
hasFlag := flags & 0b0000_0100 != 0  // true

Niente conversioni implicite

1 + 1.5 in Go compila, perché entrambi sono letterali non tipati. Ma var i int = 1; i + 1.5 NO: serve float64(i) + 1.5.

i := 1
f := 1.5
// i + f          // ERRORE
float64(i) + f    // 2.5

Prova tu

a, b := 7, 2
fmt.Println(a/b, a%b)

Recap

• Aritmetici classici; / tra int è divisione intera (tronca).
• ++ e -- sono statement, non espressioni: niente y := x++.
• Confronto e logici producono bool; &&/|| cortocircuitano.
• Bitwise & | ^ << >> &^ per flag e parsing binario.
• Nessuna conversione implicita tra tipi diversi: usa tipo(x).