Exploitanten

Go heeft de klassieke operators die je zou verwachten, met enkele verrassingen: rekenkundig, vergelijkend, logisch, bitgewijs. Geen ternaire operator (a ? b : c), geen overbelasting, geen impliciete conversies tussen typen. Eenvoud is een eigenschap.

Rekenkundig

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)

Verhogen en verlagen zijn VERKLARINGEN, geen uitdrukkingen

x++ en x-- produceren geen waarde: het zijn "acties" en niets meer. Geen y := x++ zoals in C.

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

Vergelijking

== != < <= > >= retourneert bool. Ze zijn van toepassing op cijfers en tekenreeksen; voor structs ALLE velden moeten vergelijkbaar zijn (geen segmenten/kaarten erin).

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

Logisch bij kortsluiting

&&, ||, !. Ze kortsluiten van links naar rechts: als de eerste operand is voldoende om het resultaat te bepalen, de tweede is niet even geëvalueerd.

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

Bitsgewijs

& AND, | OF, ^ XOR, << linker shift, >> rechter shift, &^ AND NIET (beetje duidelijk). Ze zijn handig voor vlaggen, binaire parsering en optimalisaties:

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

Geen impliciete conversies

1 + 1.5 in Go compileert, omdat beide niet-getypeerde letterlijke waarden zijn. Maar var i int = 1; i + 1.5 doet dat NIET: je hebt float64(i) + 1.5 nodig.

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

Jouw beurt

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

Samenvatten

• Klassieke rekenkunde; / tussen ints is deling van gehele getallen (afgekapt).
• ++ en -- zijn uitspraken, geen uitdrukkingen: nee y := x++.
• Vergelijking en logische operatoren produceren bool; &&/|| kortsluiting.
• Bitsgewijze & | ^ << >> &^ voor vlaggen en binaire parsering.
• Geen impliciete conversies tussen verschillende typen: gebruik type(x).