Go From Zero to Hero #06: Logika Percabangan Bagian 2 - Mengenal Switch Case di Go

Haloo Go Developers! Selamat datang kembali di seri belajar Go From Zero to Hero.

Nah, setelah kemarin kita belajar gimana bikin program mengambil keputusan, sekarang bayangin situasi ini: Anda lagi bikin fitur untuk ngecek hari. Kalau Senin tampilkan teks A, kalau Selasa teks B, Rabu teks C, sampai ketemu hari Minggu.

Kalau pakai if-else, kode Anda bakal panjang banget ke bawah dan dipenuhin sama tumpukan else if. Jujur aja, ngeliatnya aja udah bikin pusing, apalagi kalau nanti ada bug yang harus diperbaiki. Kode jadi kelihatan berantakan dan nggak estetik sama sekali.

Untungnya, Go punya cara yang lebih asyik dan rapi buat mengatasi masalah ini, yaitu pakai Switch Case.

Konsepnya simpel banget: bayangin switch case adalah rak atau laci perintah kerja yang menampung perintah - perintah yang akan di eksekusi program. Menariknya lagi, switch case di Go itu punya aturan yang beda dari bahasa pemrograman kebanyakan—kita nggak perlu repot-repot nulis perintah break di setiap cabangnya! Lebih hemat ketikan, kan?

Yuk, buka laptop dan teks editor andalanmu. Kita akan rapikan kode kita biar kelihatan lebih profesional dan enak dibaca!

Konsep Dasar Switch Case

Sebelum kita ke kode program sebaiknya kamu tahu dulu analogi atau sistem kerja dari switsh sace ini agar kamu tidak bingung nantinya.

Bayangkan Switch Case adalah rak atau laci perintah yang di mana setiap laci nya ada identitas atau nama laci di bagian depannya, jika terdapat input yang sama dengan nama laci tersebut maka program akan langsung menjalankan kode yang ada di dalam laci tersebut dan mengabaikan laci lainnya. Lalu bagaimana jika input tidak ada yang sama dengan nama laci manapun..? program akan mengeksekusi laci paling bawah yang sudah disediakan jika input tidak ada yang sama dengan nama laci nama lacinya (default).

Kenapa kamu harus pakai switch case ini..?

Alasan utamanya adalah agar kodemu rapi dan mudah di baca agar kamu gak pusing melihat banyak percabangan. Karena switch case ini sangat cocok untuk menangani kasus yang memiliki banyak percabangan. Dibandingkan dengan if-else yang panjang dan bikin mual bacanya, if-else cocok digunakan untuk percabangan skala kecil kalau switch case menangani percabangan skala besar.

Sintaks Dasar Switch Case di Go

Sekarang kita masuk ke bagian serunya: bagaimana cara penulisannya di Go? dan bagaimana struktur kodenya? mari kita bahas bersama-sama.

switch variabel {
    case nilai1:
        // kode yang dijalankan kalau cocok dengan nilai1
    case nilai2:
        // kode yang dijalankan kalau cocok dengan nilai2
    default:
        // laci terakhir kalau tidak ada yang cocok
}

Sintaks dasarnya hanya seperti ini simple kan, untuk lebih memahami sintaksnya ayo kita coba koding dengan menggunkan fungsi switch case ini. kita akan membuat program jadwal sekolah dengan input hari dan output jadwal dan jam.

package main
import "fmt"

func main() {
    var hari string //Variable sementara untuk menyimpan data input

    fmt.Print("Masukkan Hari: ") //membuat tampilan input
    fmt.Scan(&hari) //input di simpan di variable hari

    switch hari { //memberi tahu switch data yang harus di cek di variable hari
    case "senin":
        fmt.Println("B.Indonesia (13.00-14.00)\nPancasila (14.00-15.00)")
    case "selasa":
        fmt.Println("Matematika (08.00-10.00)\nAgama (10.00-12.00)")
    case "rabu":
        fmt.Println("B.Inggris (09.00-11.00)")
    case "kamis":
        fmt.Println("IPA (13.00-15.00)")
    case "jumat":
        fmt.Println("IPS (11.00-13.00)\nOlahraga(08-00-09.00)")
    default:
        fmt.Println("Hari libur ngapain sekolah!")
    }
}

Keunikan switch Case di Go

Ada beberapa hal unik yang membedakan Go dengan bahasa lain, ayo kita bahas apa aja sihh hall uniknya.

Tidak Perlu Break (Otomatis Berhenti)

kalau kamu menggunakan bahasa lain kamu harus menulis break di akhir kode case agar program tidak mengeksekusi kode case lain atau simpelnya break untuk keluar dari switch case dan menjalankan kode lain. Di Go kamu tidak perlu repot-repot melakukan hal tersebut karena Go akan otomatis berhenti dan keluar dari fungsi switch case di akhir case.

Dapat Memakai Banyak Kondisi Dalam Satu Case

Misalkan kamu ingin mengolah beberapa perintah yang sama misal seperti kasus berikut:

switch hari {
case "sabtu", "minggu":
    fmt.Println("Waktunya libur dan rebahan!")
case "senin", "selasa", "rabu", "kamis", "jumat":
    fmt.Println("Waktunya kerja/kuliah.")
}

Jadi, switch case di Go itu dapat ngecek beberapa kondisi sekaligus dalam satu baris. Daripada kamu harus menggunakan gerbang logika atau menulis case terpisah satu-persatu padahal ujung-ujungnya ngelakuin hal yang sama, mending digabungin aja kayak contoh di atas. Jauh lebih hemat baris kode dan rapi, kan?

Fitur Fallthrough (Kebalikan dari Break)

Nah, di poin pertama tadi kita udah tahu kalau Go itu bakal otomatis berhenti (break) kalau sudah menemukan case yang cocok. Tapi, bagaimana kalau kamu justru ingin programnya tetep lanjut Menjalankan kode di case bawahnya, walaupun kondisi di bawahnya itu tidak cocok?

Di Go, kamu bisa pakai kata kunci fallthrough. Jadi, fungsi fallthrough ini ibaratnya sengaja bikin laci di bawahnya ikut terbuka.

Contoh penggunaannya kayak Seperti ini:

package main
import "fmt"

func main() {
    pangkat := "captain"

    switch pangkat {
    case "general":
        fmt.Println("Akses Nuklir Aktif.")
        fallthrough
    case "captain":
        fmt.Println("Akses Ruang Senjata Aktif.")
        fallthrough
    case "soldier":
        fmt.Println("Akses Gerbang Utama Aktif.")
    }
}

Kalau kode di atas kamu jalankan, variabel pangkat itu isinya “captain”. Program akan langsung masuk ke case “captain” dan mencetak “Akses Ruang Senjata Aktif.”.

Tapi karena di bawahnya ada kata fallthrough, program bakal maksa langsung turun ke bawahnya lagi (ke case “soldier”) dan ikutan mencetak “Akses Gerbang Utama Aktif.”, padahal isi variabelnya bukan “soldier”.

Fitur ini berguna banget kalau kamu mau bikin sistem hak akses bertingkat kayak contoh di atas.

Switch Tanpa Kondisi (Switch Tagless)

Di bahasa pemrograman lain, switch itu wajib banget dipasangkan sama variabel di sampingnya (misal: switch hari). Tapi di Go, ada fitur keren namanya Switch Tagless alias switch kosongan tanpa variabel!

Sebagai gantinya, kamu bisa menaruh logika perbandingan (seperti >, <, ==) dan menggabungkannya dengan Operator Logika (seperti && atau ||) langsung di dalam setiap case-nya. Fitur ini membuat switch bisa menggantikan peran if-else bertingkat dengan jauh lebih rapi.

Biar gak bingung, coba lihat contoh program penentu nilai ujian ini:

package main
import "fmt"

func main() {
    nilai := 85

    // Perhatikan: di samping kata 'switch' gak ada variabelnya sama sekali
    switch {
    case nilai >= 80 && nilai <= 100:
        fmt.Println("Nilai kamu A. Pertahankan!")
    case nilai >= 70 && nilai < 80:
        fmt.Println("Nilai kamu B. Bagus!")
    case nilai >= 50 && nilai < 70:
        fmt.Println("Nilai kamu C. Belajar lagi ya!")
    default:
        fmt.Println("Nilai kamu D atau input salah.")
    }
}

Kalau kode di atas dijalankan, Go akan langsung mengecek satu-persatu case dari atas ke bawah, persis seperti cara kerja if-else.

Karena variabel nilai isinya 85, dan 85 itu berada di rentang >= 80 DAN (&&) <= 100, maka case pertama langsung aktif dan mencetak “Nilai kamu A. Pertahankan!”.

Kapan harus pakai fitur ini? Kamu bisa pakai Switch Tagless kalau kondisi yang mau kamu cek sudah mulai kompleks (bukan cuma sekadar mencocokkan teks/angka biasa), tapi kamu tetap pengen struktur kodemu kelihatan bersih dan gak bulletproof kayak tumpukan if-else-if yang panjang.

🛠️ Tantangan Mini: Waktunya Unjuk Gigi!

Agar ilmu Switch Case yang baru kamu pelajari gak menguap begitu saja, yuk coba selesaikan tantangan mini ini. Jangan cuma dibaca, langsung buka text editor kamu dan ketik kodenya!

Studi Kasus: Sistem Penentu Status Lampu Lalu Lintas Buatlah sebuah program Go yang menerima input berupa warna lampu lalu lintas (string) dari user, lalu cetak perintahnya menggunakan switch case:

1. Jika user menginput "merah", cetak: "Berhenti! Jalur ditutup."
2. Jika user menginput "kuning", cetak: "Hati-Hati! Kurangi kecepatan."
3. Jika user menginput "hijau", cetak: "Jalan! Tetap berhati-hati."
4. Jika user menginput warna lain (misal: “biru” atau “ungu”), gunakan default untuk mencetak: "Warna lampu tidak valid!"

Tips: Ingat keunikan Go, kamu tidak perlu menuliskan kata kunci break di setiap case-nya!

📝 Kesimpulan

Kita sudah bahas tuntas nih tentang switch case di bahasa Go. Kalau kita rangkum, ini dia poin-poin penting yang wajib kamu ingat:

• Lebih Bersih: switch case adalah alternatif terbaik pengganti if-else bertingkat kalau kondisi yang mau kamu cek sudah terlalu banyak dan berfokus pada satu variabel.
• Anti-Bocor: Di Go, switch case secara default sudah otomatis berhenti (implicit break), jadi kamu gak bakal nemu bug gara-gara kelupaan nulis break.
• Sangat Fleksibel: Go punya fitur keren seperti menggabungkan banyak kondisi dengan tanda koma (,), memaksa kode lanjut ke bawah dengan fallthrough, hingga bikin switch kosongan (Switch Tagless) buat logika yang lebih kompleks.

Sampai di sini, kamu sudah menguasai dua senjata utama dalam kendali alur (control flow) di bahasa Go, yaitu if-else dan switch case.

Di artikel selanjutnya, kita bakal bahas materi yang gak kalah seru dan sering bikin pusing kalau nggak dipahami pelan-pelan: Perulangan (Looping) di Go. Siap buat naik level berikutnya? Sampai jumpa di artikel #07!