BAB 9: Operator — Aritmatika, Perbandingan, dan Logika

Konstanta yang kita pelajari di bab sebelumnya berguna untuk menyimpan nilai yang tidak berubah — tapi program yang hanya menyimpan nilai belum bisa melakukan apapun yang bermakna. Supaya data bisa diolah, dibandingkan, dan digunakan untuk membuat keputusan, kamu membutuhkan operator.

Operator adalah simbol yang memberi tahu Go operasi apa yang harus dilakukan terhadap satu atau lebih nilai. Ada tiga kelompok yang perlu kamu kuasai: operator aritmatika untuk perhitungan, operator perbandingan untuk menghasilkan nilai true/false, dan operator logika untuk menggabungkan kondisi. Ketiganya akan muncul di hampir setiap program yang kamu tulis.

Operator Aritmatika

Go mendukung semua operasi matematika dasar. Simbolnya familiar — sama seperti yang kamu tulis di kertas:

// main.go
package main

import "fmt"

func main() {
    a := 10
    b := 3

    fmt.Printf("%d + %d = %d\n", a, b, a+b)
    fmt.Printf("%d - %d = %d\n", a, b, a-b)
    fmt.Printf("%d * %d = %d\n", a, b, a*b)
    fmt.Printf("%d / %d = %d\n", a, b, a/b)
    fmt.Printf("%d %% %d = %d\n", a, b, a%b)
}

10 + 3 = 13
10 - 3 = 7
10 * 3 = 30
10 / 3 = 3
10 % 3 = 1

Perhatikan hasil 10 / 3 = 3, bukan 3.33. Ketika kedua operand bertipe integer, Go melakukan integer division — hasil desimalnya dibuang, bukan dibulatkan. Jika kamu butuh hasil desimal, setidaknya satu operand harus bertipe float64:

// main.go
package main

import "fmt"

func main() {
    a := 10.0  // float64
    b := 3.0

    fmt.Printf("%.2f / %.2f = %.4f\n", a, b, a/b)
    // Output: 10.00 / 3.00 = 3.3333
}

Operator Assignment Singkat

Daripada menulis angka = angka + 5, Go menyediakan versi ringkas yang menggabungkan operasi dengan assignment:

// main.go
package main

import "fmt"

func main() {
    n := 10
    fmt.Println("awal:", n)

    n += 5  // n = n + 5
    fmt.Println("+=5:", n)

    n -= 3  // n = n - 3
    fmt.Println("-=3:", n)

    n *= 2  // n = n * 2
    fmt.Println("*=2:", n)

    n /= 4  // n = n / 4
    fmt.Println("/=4:", n)

    n %= 3  // n = n % 3
    fmt.Println("%=3:", n)
}

awal: 10
+=5: 15
-=3: 12
*=2: 24
/=4: 6
%=3: 0

Operator Perbandingan

Operator perbandingan membandingkan dua nilai dan selalu menghasilkan bool — true atau false. Inilah alat yang nantinya kamu gunakan untuk membuat percabangan if.

// main.go
package main

import "fmt"

func main() {
    nilai := 85
    batasLulus := 75

    fmt.Printf("nilai: %d, batas lulus: %d\n\n", nilai, batasLulus)
    fmt.Printf("nilai >= batasLulus : %t\n", nilai >= batasLulus)
    fmt.Printf("nilai == 100        : %t\n", nilai == 100)
    fmt.Printf("nilai != batasLulus : %t\n", nilai != batasLulus)
    fmt.Printf("nilai < batasLulus  : %t\n", nilai < batasLulus)
}

nilai: 85, batas lulus: 75

nilai >= batasLulus : true
nilai == 100        : false
nilai != batasLulus : true
nilai < batasLulus  : false

Operator perbandingan juga bekerja pada string. Go membandingkan string secara leksikografis (urutan alfabet):

// main.go
package main

import "fmt"

func main() {
    kota1 := "Bandung"
    kota2 := "Jakarta"
    kota3 := "Bandung"

    fmt.Println(kota1 == kota3)  // true
    fmt.Println(kota1 == kota2)  // false
    fmt.Println(kota1 < kota2)   // true ("B" < "J" secara alfabet)
}

Operator Logika

Operator logika menggabungkan atau membalik nilai bool. Kamu akan sering menggunakannya saat membuat kondisi yang melibatkan lebih dari satu syarat.

// main.go
package main

import "fmt"

func main() {
    umur := 20
    punyaSIM := true

    bolehMenyetir := umur >= 17 && punyaSIM
    fmt.Printf("Boleh menyetir: %t\n", bolehMenyetir)

    perluDaftar := !punyaSIM
    fmt.Printf("Perlu daftar SIM: %t\n", perluDaftar)

    bisaMasuk := umur >= 17 || punyaSIM
    fmt.Printf("Bisa masuk kategori: %t\n", bisaMasuk)
}

Boleh menyetir: true
Perlu daftar SIM: false
Bisa masuk kategori: true

Go mengevaluasi operator logika dengan short-circuit evaluation. Pada &&, jika sisi kiri sudah false, sisi kanan tidak dievaluasi sama sekali. Pada ||, jika sisi kiri sudah true, sisi kanan dilewati. Ini penting ketika sisi kanan melibatkan operasi yang mahal atau bisa menghasilkan error.

Menggabungkan Semua Operator

Berikut contoh yang menggabungkan ketiga jenis operator dalam satu kasus yang lebih realistis — menghitung nilai akhir mahasiswa dan menentukan status kelulusannya:

// main.go
package main

import "fmt"

func main() {
    nama := "Sari"
    nilaiUTS := 75
    nilaiUAS := 80
    kehadiran := 85 // persen

    // Aritmatika: hitung nilai akhir (40% UTS + 60% UAS)
    nilaiAkhir := (nilaiUTS*40 + nilaiUAS*60) / 100

    // Perbandingan: cek tiap syarat
    syaratNilai := nilaiAkhir >= 70
    syaratKehadiran := kehadiran >= 80

    // Logika: gabungkan syarat
    lulus := syaratNilai && syaratKehadiran

    fmt.Printf("Nama         : %s\n", nama)
    fmt.Printf("Nilai akhir  : %d\n", nilaiAkhir)
    fmt.Printf("Kehadiran    : %d%%\n", kehadiran)
    fmt.Printf("Syarat nilai : %t\n", syaratNilai)
    fmt.Printf("Syarat hadir : %t\n", syaratKehadiran)
    fmt.Printf("Status lulus : %t\n", lulus)
}

Nama         : Sari
Nilai akhir  : 78
Kehadiran    : 85%
Syarat nilai : true
Syarat hadir : true
Status lulus : true

Latihan

Latihan 1 — Kalkulator modulus: Tulis program yang menentukan apakah sebuah angka genap atau ganjil menggunakan operator %. Tampilkan juga sisa bagi angka tersebut jika dibagi 3, 5, dan 7.

Latihan 2 — Konversi suhu: Buat program yang mengonversi suhu dari Celsius ke Fahrenheit menggunakan rumus F = (C * 9/5) + 32. Pastikan kamu menggunakan float64 untuk mendapatkan hasil yang akurat. Tampilkan apakah suhu tersebut di atas titik beku (0°C) dan di bawah titik didih (100°C).

Latihan 3 — Syarat tiket konser: Buat program dengan variabel umur, punyaTiket, dan sudahDaftar. Tulis ekspresi boolean yang menentukan: apakah seseorang boleh masuk (umur di atas 17 DAN punya tiket), apakah perlu verifikasi (punya tiket TAPI belum daftar), dan apakah ditolak masuk (tidak punya tiket ATAU di bawah umur).

Operator memberi kamu kemampuan untuk menghitung dan membandingkan — tapi hasilnya masih hanya true atau false yang disimpan di variabel. Supaya program bisa bereaksi berdasarkan nilai tersebut, kamu butuh struktur kontrol. Di bab berikutnya, kita akan menggunakan hasil operator perbandingan dan logika ini sebagai fondasi percabangan if, else, dan switch.

Referensi

1. 1Operators — The Go Programming Language Specification
2. 2Operator Precedence — The Go Programming Language Specification
3. 3For — A Tour of Go (contoh penggunaan operator dalam konteks loop)