Operator

Go memiliki operator klasik yang Anda harapkan, dengan beberapa kejutan: aritmatika, perbandingan, logis, bitwise. Tidak ada operator ternary (a ? b : c), tidak ada kelebihan beban, tidak ada konversi implisit antar jenis. Kesederhanaan adalah sebuah fitur.

Hitung

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)

Kenaikan dan penurunan adalah PERNYATAAN, bukan ekspresi

x++ dan x-- tidak menghasilkan nilai: keduanya adalah "tindakan" dan bukan apa-apa lebih. Tidak ada y := x++ seperti di C.

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

Perbandingan

== != < <= > >= kembalikan bool. Mereka berlaku untuk angka dan string; untuk struct SEMUA bidang harus sebanding (tidak ada irisan/peta di dalamnya).

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

Logis dengan korsleting

&&, ||, !. Mereka mengalami hubungan pendek dari kiri ke kanan: jika yang pertama operan sudah cukup untuk menentukan hasilnya, yang kedua tidak genap dievaluasi.

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

Sedikit demi sedikit

& AND, | OR, ^ XOR, << shift kiri, >> shift kanan, &^ AND TIDAK (agak jelas). Mereka berguna untuk flag, penguraian biner dan optimasi:

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

Tidak ada konversi implisit

1 + 1.5 di Go dikompilasi, karena keduanya merupakan literal yang tidak diketik. Namun var i int = 1; i + 1.5 TIDAK: Anda memerlukan float64(i) + 1.5.

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

Giliranmu

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

Rekap

• Aritmatika klasik; / antar int adalah pembagian bilangan bulat (terpotong).
• ++ dan -- merupakan pernyataan, bukan ekspresi: tidak ada y := x++.
• Operator perbandingan dan logika menghasilkan bool; &&/|| hubungan pendek.
• Bitwise & | ^ << >> &^ untuk flag dan penguraian biner.
• Tidak ada konversi implisit antara jenis yang berbeda: gunakan type(x).