Operadores

Go tiene los operadores clásicos que esperarías, con pocas sorpresas: aritmética, comparación, lógica, bit a bit. Sin operador ternario (a ? b : c), sin sobrecarga, sin conversiones implícitas entre tipos. La simplicidad es una característica.

Aritmética

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)

El incremento y la disminución son DECLARACIONES, no expresiones

x++ y x-- no producen un valor: son "acciones" y nada más. No hay y := x++ como en C.

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

Comparación

CÓDIGOPH0 devuelve CÓDIGOPH1. Se aplican a números y cadenas; para estructuras TODOS los campos deben ser comparables (sin sectores/mapas dentro).

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

Lógico con cortocircuito

CÓDIGOPH0, CÓDIGOPH1, CÓDIGOPH2. Se cortocircuitan de izquierda a derecha: si el primero El operando es suficiente para determinar el resultado, el segundo ni siquiera es evaluado.

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

Bit a bit

& Y, | O, ^ XOR, << desplazamiento a la izquierda, >> desplazamiento a la derecha, &^ Y NO (un poco claro). Son útiles para banderas, análisis binario y optimizaciones:

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

Sin conversiones implícitas

1 + 1.5 en Go compila, porque ambos son literales sin tipo. Pero var i int = 1; i + 1.5 NO: necesitas float64(i) + 1.5.

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

Tu turno

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

Resumen

• Aritmética clásica; / entre ints es una división de enteros (se trunca).
• ++ y -- son declaraciones, no expresiones: no y := x++.
• Los operadores lógicos y de comparación producen bool; Cortocircuito &&/||.
• & | ^ << >> &^ bit a bit para indicadores y análisis binario.
• No hay conversiones implícitas entre diferentes tipos: use type(x).