BAB 9: Operator - Dasar Perhitungan dan Logika

Dari konstanta yang udah kita pelajari di bab sebelumnya, sekarang waktunya mengenal operator—tools yang akan membantu kamu melakukan berbagai operasi dalam program. Operator ini kayak kalkulator digital yang bisa melakukan perhitungan matematika, membandingkan nilai, dan membuat keputusan logis.

Go menyediakan tiga jenis operator utama yang akan sering kamu gunakan: operator aritmatika untuk perhitungan, operator perbandingan untuk membandingkan nilai, dan operator logika untuk mengombinasikan kondisi. Dengan memahami ketiga jenis operator ini, kamu bisa membuat program yang lebih interaktif dan dinamis.

Operator Aritmatika: Kalkulator dalam Code

Operator aritmatika adalah operator yang digunakan untuk melakukan operasi perhitungan matematika. Go mendukung semua operasi dasar matematika yang biasa kamu gunakan.

Jenis-jenis Operator Aritmatika

Berikut adalah operator aritmatika yang tersedia di Go:

Operator	Fungsi	Contoh
`+`	Penjumlahan	`5 + 3 = 8`
`-`	Pengurangan	`10 - 4 = 6`
`*`	Perkalian	`6 * 7 = 42`
`/`	Pembagian	`15 / 3 = 5`
`%`	Modulus (sisa bagi)	`17 % 5 = 2`

Contoh Penggunaan Operator Aritmatika

Mari kita lihat bagaimana menggunakan operator aritmatika dalam program:

package main

import "fmt"

func main() {
    // Deklarasi variable untuk perhitungan
    angka1 := 10
    angka2 := 3
    
    // Operasi aritmatika dasar
    penjumlahan := angka1 + angka2
    pengurangan := angka1 - angka2
    perkalian := angka1 * angka2
    pembagian := angka1 / angka2  // Pembagian integer
    sisaBagi := angka1 % angka2
    
    fmt.Println("=== Hasil Operasi Aritmatika ===")
    fmt.Printf("%d + %d = %d\n", angka1, angka2, penjumlahan)
    fmt.Printf("%d - %d = %d\n", angka1, angka2, pengurangan)
    fmt.Printf("%d * %d = %d\n", angka1, angka2, perkalian)
    fmt.Printf("%d / %d = %d\n", angka1, angka2, pembagian)
    fmt.Printf("%d %% %d = %d\n", angka1, angka2, sisaBagi)
}

Output:

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

Operasi dengan Urutan Prioritas

Sama seperti matematika pada umumnya, Go juga mengikuti urutan prioritas operasi (operator precedence):

package main

import "fmt"

func main() {
    // Operasi kompleks dengan urutan prioritas
    hasil := (((2 + 6) % 3) * 4 - 2) / 3
    
    fmt.Println("Operasi: (((2 + 6) % 3) * 4 - 2) / 3")
    fmt.Printf("Hasil: %d\n", hasil)
    
    // Mari kita hitung step by step
    step1 := 2 + 6        // = 8
    step2 := step1 % 3    // = 2
    step3 := step2 * 4    // = 8
    step4 := step3 - 2    // = 6
    step5 := step4 / 3    // = 2
    
    fmt.Println("\n=== Step by Step ===")
    fmt.Printf("2 + 6 = %d\n", step1)
    fmt.Printf("8 %% 3 = %d\n", step2)
    fmt.Printf("2 * 4 = %d\n", step3)
    fmt.Printf("8 - 2 = %d\n", step4)
    fmt.Printf("6 / 3 = %d\n", step5)
}

Output:

Operasi: (((2 + 6) % 3) * 4 - 2) / 3
Hasil: 2

=== Step by Step ===
2 + 6 = 8
8 % 3 = 2
2 * 4 = 8
8 - 2 = 6
6 / 3 = 2

Operator Perbandingan: Membandingkan Nilai

Operator perbandingan digunakan untuk membandingkan dua nilai dan menghasilkan nilai boolean (true atau false). Operator ini sangat berguna untuk membuat keputusan dalam program.

Jenis-jenis Operator Perbandingan

Operator	Fungsi	Contoh
`==`	Sama dengan	`5 == 5` → `true`
`!=`	Tidak sama dengan	`5 != 3` → `true`
`<`	Lebih kecil dari	`3 < 5` → `true`
`<=`	Lebih kecil atau sama dengan	`5 <= 5` → `true`
`>`	Lebih besar dari	`7 > 3` → `true`
`>=`	Lebih besar atau sama dengan	`6 >= 6` → `true`

Contoh Penggunaan Operator Perbandingan

package main

import "fmt"

func main() {
    nilai := 85
    bataslulus := 75
    
    // Operator perbandingan
    lulus := nilai >= bataslulus
    nilaiSempurna := nilai == 100
    tidakLulus := nilai < bataslulus
    
    fmt.Printf("Nilai: %d\n", nilai)
    fmt.Printf("Batas lulus: %d\n", bataslulus)
    fmt.Printf("Apakah lulus? %t\n", lulus)
    fmt.Printf("Apakah nilai sempurna? %t\n", nilaiSempurna)
    fmt.Printf("Apakah tidak lulus? %t\n", tidakLulus)
    
    // Contoh perbandingan string
    nama1 := "Budi"
    nama2 := "Andi"
    nama3 := "Budi"
    
    fmt.Printf("\n=== Perbandingan String ===\n")
    fmt.Printf("'%s' == '%s' : %t\n", nama1, nama2, nama1 == nama2)
    fmt.Printf("'%s' == '%s' : %t\n", nama1, nama3, nama1 == nama3)
    fmt.Printf("'%s' != '%s' : %t\n", nama1, nama2, nama1 != nama2)
}

Output:

Nilai: 85
Batas lulus: 75
Apakah lulus? true
Apakah nilai sempurna? false
Apakah tidak lulus? false

=== Perbandingan String ===
'Budi' == 'Andi' : false
'Budi' == 'Budi' : true
'Budi' != 'Andi' : true

Tips Penggunaan Layout Format Boolean

Untuk menampilkan nilai boolean dalam fmt.Printf(), gunakan layout format %t:

package main

import "fmt"

func main() {
    umur := 17
    dewasa := umur >= 18
    
    fmt.Printf("Umur: %d tahun\n", umur)
    fmt.Printf("Status dewasa: %t\n", dewasa)
    
    if dewasa {
        fmt.Println("Sudah boleh punya SIM")
    } else {
        fmt.Println("Belum boleh punya SIM")
    }
}

Output:

Umur: 17 tahun
Status dewasa: false
Belum boleh punya SIM

Operator Logika: Mengombinasikan Kondisi

Operator logika digunakan untuk mengombinasikan atau memodifikasi nilai boolean. Operator ini sangat berguna ketika kamu perlu menggabungkan beberapa kondisi dalam satu pengujian.

Jenis-jenis Operator Logika

Operator	Fungsi	Deskripsi
`&&`	AND (dan)	Kedua kondisi harus `true`
`\|\|`	OR (atau)	Salah satu kondisi harus `true`
`!`	NOT (negasi)	Membalik nilai boolean

Contoh Penggunaan Operator Logika

package main

import "fmt"

func main() {
    // Variable boolean untuk demonstrasi
    cuacaCerah := true
    punyaUang := false
    libur := true
    
    fmt.Println("=== Status Kondisi ===")
    fmt.Printf("Cuaca cerah: %t\n", cuacaCerah)
    fmt.Printf("Punya uang: %t\n", punyaUang)
    fmt.Printf("Libur: %t\n", libur)
    
    // Operator AND (&&)
    bisaJalan := cuacaCerah && punyaUang
    fmt.Printf("\nBisa jalan-jalan (cuaca cerah DAN punya uang): %t\n", bisaJalan)
    
    // Operator OR (||)
    bisaRelax := libur || cuacaCerah
    fmt.Printf("Bisa santai (libur ATAU cuaca cerah): %t\n", bisaRelax)
    
    // Operator NOT (!)
    tidakPunyaUang := !punyaUang
    fmt.Printf("Tidak punya uang: %t\n", tidakPunyaUang)
    
    // Kombinasi kompleks
    bisaNonton := (libur && cuacaCerah) || !punyaUang
    fmt.Printf("Bisa nonton di rumah: %t\n", bisaNonton)
}

Output:

=== Status Kondisi ===
Cuaca cerah: true
Punya uang: false
Libur: true

Bisa jalan-jalan (cuaca cerah DAN punya uang): false
Bisa santai (libur ATAU cuaca cerah): true
Tidak punya uang: true
Bisa nonton di rumah: true

Memahami Logika AND, OR, dan NOT

Mari kita pelajari bagaimana operator logika bekerja dengan contoh yang lebih detail:

package main

import "fmt"

func main() {
    fmt.Println("=== Truth Table AND (&&) ===")
    fmt.Printf("true && true = %t\n", true && true)
    fmt.Printf("true && false = %t\n", true && false)
    fmt.Printf("false && true = %t\n", false && true)
    fmt.Printf("false && false = %t\n", false && false)
    
    fmt.Println("\n=== Truth Table OR (||) ===")
    fmt.Printf("true || true = %t\n", true || true)
    fmt.Printf("true || false = %t\n", true || false)
    fmt.Printf("false || true = %t\n", false || true)
    fmt.Printf("false || false = %t\n", false || false)
    
    fmt.Println("\n=== Truth Table NOT (!) ===")
    fmt.Printf("!true = %t\n", !true)
    fmt.Printf("!false = %t\n", !false)
}

Output:

=== Truth Table AND (&&) ===
true && true = true
true && false = false
false && true = false
false && false = false

=== Truth Table OR (||) ===
true || true = true
true || false = true
false || true = true
false || false = false

=== Truth Table NOT (!) ===
!true = false
!false = true

Kombinasi Operator dalam Skenario Nyata

Sekarang mari kita lihat bagaimana mengombinasikan semua jenis operator dalam skenario nyata:

package main

import "fmt"

func main() {
    // Data mahasiswa
    nama := "Sari"
    nilaiUTS := 75
    nilaiUAS := 80
    kehadiran := 85 // persen
    
    // Hitung nilai akhir (40% UTS + 60% UAS)
    nilaiAkhir := (nilaiUTS * 40 / 100) + (nilaiUAS * 60 / 100)
    
    // Syarat lulus
    syaratNilai := nilaiAkhir >= 70
    syaratKehadiran := kehadiran >= 80
    lulus := syaratNilai && syaratKehadiran
    
    // Kategorisasi nilai
    predikatA := nilaiAkhir >= 85
    predikatB := nilaiAkhir >= 75 && nilaiAkhir < 85
    predikatC := nilaiAkhir >= 70 && nilaiAkhir < 75
    
    fmt.Printf("=== Laporan Nilai %s ===\n", nama)
    fmt.Printf("Nilai UTS: %d\n", nilaiUTS)
    fmt.Printf("Nilai UAS: %d\n", nilaiUAS)
    fmt.Printf("Kehadiran: %d%%\n", kehadiran)
    fmt.Printf("Nilai Akhir: %d\n", nilaiAkhir)
    
    fmt.Printf("\n=== Evaluasi ===\n")
    fmt.Printf("Memenuhi syarat nilai (>= 70): %t\n", syaratNilai)
    fmt.Printf("Memenuhi syarat kehadiran (>= 80%%): %t\n", syaratKehadiran)
    fmt.Printf("Status Lulus: %t\n", lulus)
    
    fmt.Printf("\n=== Predikat ===\n")
    fmt.Printf("Predikat A (>= 85): %t\n", predikatA)
    fmt.Printf("Predikat B (75-84): %t\n", predikatB)
    fmt.Printf("Predikat C (70-74): %t\n", predikatC)
}

Output:

=== Laporan Nilai Sari ===
Nilai UTS: 75
Nilai UAS: 80
Kehadiran: 85%
Nilai Akhir: 78

=== Evaluasi ===
Memenuhi syarat nilai (>= 70): true
Memenuhi syarat kehadiran (>= 80%): true
Status Lulus: true

=== Predikat ===
Predikat A (>= 85): false
Predikat B (75-84): true
Predikat C (70-74): false

Tips Format Output yang Rapi

Untuk membuat output yang lebih rapi dan mudah dibaca, kamu bisa menggunakan escape sequence \t untuk menambahkan tab:

package main

import "fmt"

func main() {
    x := 10
    y := 5
    
    fmt.Println("=== Perbandingan Nilai ===")
    fmt.Printf("x = %d, y = %d\n", x, y)
    fmt.Printf("x == y\t: %t\n", x == y)
    fmt.Printf("x != y\t: %t\n", x != y)
    fmt.Printf("x > y\t: %t\n", x > y)
    fmt.Printf("x < y\t: %t\n", x < y)
    fmt.Printf("x >= y\t: %t\n", x >= y)
    fmt.Printf("x <= y\t: %t\n", x <= y)
}

Output:

=== Perbandingan Nilai ===
x = 10, y = 5
x == y  : false
x != y  : true
x > y   : true
x < y   : false
x >= y  : true
x <= y  : false

Operator Assignment Singkat

Go juga menyediakan operator assignment yang mengombinasikan operasi aritmatika dengan assignment:

package main

import "fmt"

func main() {
    angka := 10
    fmt.Printf("Nilai awal: %d\n", angka)
    
    angka += 5  // sama dengan: angka = angka + 5
    fmt.Printf("Setelah += 5: %d\n", angka)
    
    angka -= 3  // sama dengan: angka = angka - 3
    fmt.Printf("Setelah -= 3: %d\n", angka)
    
    angka *= 2  // sama dengan: angka = angka * 2
    fmt.Printf("Setelah *= 2: %d\n", angka)
    
    angka /= 4  // sama dengan: angka = angka / 4
    fmt.Printf("Setelah /= 4: %d\n", angka)
    
    angka %= 3  // sama dengan: angka = angka % 3
    fmt.Printf("Setelah %%= 3: %d\n", angka)
}

Output:

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

Latihan: Kalkulator Sederhana

Mari kita buat program kalkulator sederhana yang menggunakan semua operator yang sudah kita pelajari:

package main

import "fmt"

func main() {
    fmt.Println("=== KALKULATOR SEDERHANA ===")
    
    // Input angka
    angka1 := 25.0
    angka2 := 4.0
    
    fmt.Printf("Angka pertama: %.1f\n", angka1)
    fmt.Printf("Angka kedua: %.1f\n", angka2)
    
    // Operasi aritmatika
    fmt.Printf("\n=== Operasi Aritmatika ===\n")
    fmt.Printf("%.1f + %.1f = %.1f\n", angka1, angka2, angka1+angka2)
    fmt.Printf("%.1f - %.1f = %.1f\n", angka1, angka2, angka1-angka2)
    fmt.Printf("%.1f * %.1f = %.1f\n", angka1, angka2, angka1*angka2)
    fmt.Printf("%.1f / %.1f = %.1f\n", angka1, angka2, angka1/angka2)
    
    // Operasi perbandingan
    fmt.Printf("\n=== Operasi Perbandingan ===\n")
    fmt.Printf("%.1f == %.1f : %t\n", angka1, angka2, angka1 == angka2)
    fmt.Printf("%.1f != %.1f : %t\n", angka1, angka2, angka1 != angka2)
    fmt.Printf("%.1f > %.1f  : %t\n", angka1, angka2, angka1 > angka2)
    fmt.Printf("%.1f < %.1f  : %t\n", angka1, angka2, angka1 < angka2)
    
    // Operasi logika dengan kondisi
    lebihBesar := angka1 > angka2
    genap1 := int(angka1)%2 == 0
    genap2 := int(angka2)%2 == 0
    
    fmt.Printf("\n=== Operasi Logika ===\n")
    fmt.Printf("Angka1 lebih besar: %t\n", lebihBesar)
    fmt.Printf("Angka1 genap: %t\n", genap1)
    fmt.Printf("Angka2 genap: %t\n", genap2)
    fmt.Printf("Keduanya genap: %t\n", genap1 && genap2)
    fmt.Printf("Salah satu genap: %t\n", genap1 || genap2)
    fmt.Printf("Bukan keduanya genap: %t\n", !(genap1 && genap2))
}

Output:

=== KALKULATOR SEDERHANA ===
Angka pertama: 25.0
Angka kedua: 4.0

=== Operasi Aritmatika ===
25.0 + 4.0 = 29.0
25.0 - 4.0 = 21.0
25.0 * 4.0 = 100.0
25.0 / 4.0 = 6.2

=== Operasi Perbandingan ===
25.0 == 4.0 : false
25.0 != 4.0 : true
25.0 > 4.0  : true
25.0 < 4.0  : false

=== Operasi Logika ===
Angka1 lebih besar: true
Angka1 genap: false
Angka2 genap: true
Keduanya genap: false
Salah satu genap: true
Bukan keduanya genap: true

Ringkasan

Operator adalah fondasi penting dalam programming yang memungkinkan kamu untuk:

Operator Aritmatika - Melakukan perhitungan matematika (+, -, *, /, %)
Operator Perbandingan - Membandingkan nilai dan menghasilkan boolean (==, !=, <, <=, >, >=)
Operator Logika - Mengombinasikan kondisi boolean (&&, ||, !)

Dengan menguasai ketiga jenis operator ini, kamu sudah punya tools yang powerful untuk membuat program yang bisa melakukan perhitungan, membuat keputusan, dan memproses data. Di bab selanjutnya, kita akan mempelajari cara menggunakan operator perbandingan dan logika untuk membuat program yang bisa mengambil keputusan dengan struktur kontrol if-else.

Yang penting diingat: operator ini akan menjadi building blocks untuk semua program yang kamu buat. Jadi pastikan kamu paham betul cara kerjanya, karena hampir setiap program pasti menggunakan operator dalam bentuk tertentu!