Opérateurs

Go propose les opérateurs classiques auxquels vous vous attendez, avec quelques surprises : arithmétique, comparaison, logique, bit à bit. Pas d'opérateur ternaire (a ? b : c), pas de surcharge, pas de conversions implicites entre types. La simplicité est une caractéristique.

Arithmétique

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)

L'incrémentation et la décrémentation sont des DÉCLARATIONS, pas des expressions

x++ et x-- ne produisent pas de valeur : ce sont des "actions" et rien plus. Pas de y := x++ comme en C.

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

Comparaison

== != < <= > >= renvoie bool. Ils s'appliquent aux nombres et aux chaînes ; pour structure TOUS les champs doivent être comparables (pas de tranches/cartes à l'intérieur).

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

Logique avec court-circuit

&&, ||, !. Ils court-circuitent de gauche à droite : si le premier l'opérande suffit pour déterminer le résultat, le second ne l'est même pas évalué.

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

Au niveau du bit

& ET, | OU, ^ XOR, << décalage à gauche, >> décalage à droite, &^ ET NON (un peu clair). Ils sont utiles pour les indicateurs, l'analyse binaire et optimisations :

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

Aucune conversion implicite

1 + 1.5 dans Go compile, car les deux sont des littéraux non typés. Mais var i int = 1; i + 1.5 ne le fait PAS : vous avez besoin de float64(i) + 1.5.

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

A ton tour

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

Récapitulatif

• Arithmétique classique ; / entre les entiers est une division entière (tronquée).
• ++ et -- sont des instructions, pas des expressions : pas de y := x++.
• Les opérateurs de comparaison et logiques produisent bool ; Court-circuit &&/||.
• Bitwise & | ^ << >> &^ pour les indicateurs et l'analyse binaire.
• Pas de conversions implicites entre différents types : utilisez type(x).