Go From Zero to Hero #09: Menguasai While-Loop dan Repeat-Until Ala Go-lang

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

Di artikel ketujuh kemarin, kita sudah berhasil memberi arahan komputer untuk melakukan tugas berulang-ulang lewat satu-satunya keyword perulangan di Go, yaitu for. Kita juga sudah belajar cara memodifikasi alur looping tersebut lewat analogi boks bola (break) dan boks apel busuk (continue).

Nah, di artikel kedelapan ini, kita akan mempelajari variasi perulangan tingkat lanjut yang tidak kalah penting! Kita akan berkenalan dengan konsep perulangan yang jumlah putarannya dinamis (tidak pasti), yaitu While-Loop dan Repeat-Until.

Mungkin kamu bertanya-tanya: “Lho, bukannya di Go-lang cuma ada keyword for saja?” Betul sekali! Di sinilah letak keseruannya. Kita akan mengupas tuntas trik cerdik bagaimana memanfaatkan kesederhanaan satu keyword for untuk menangani logika perulangan bersyarat, lengkap dengan analogi potong harga belanjaan hingga game tebak angka rahasia.

Di akhir artikel nanti, kamu akan paham kenapa kreator Go-lang sengaja membuang keyword while demi efisiensi kode, dan bagaimana kamu bisa menulis logika perulangan dinamis dengan jauh lebih bersih dan rapi!

Sudah siap menaikkan level logika perulangan program Go kamu? Yuk, siapkan teks editor favoritmu, ambil posisi duduk paling nyaman, dan mari kita mulai!

Apa Itu Perulangan Bersyarat? (Dan Kenapa for Saja Nggak Cukup?)

Di artikel sebelumnya, kita sudah belajar cara membuat perulangan menggunakan gaya tradisional:

for i := 1; i <= 5; i++ {
    fmt.Println("Gasing berputar ke-", i)
}

Perulangan di atas sangat bagus kalau dari awal kita sudah tahu pasti program harus berputar berapa kali (dalam contoh di atas, tepat 5 kali).

Tapi bayangkan situasi di dunia nyata seperti ini: Kamu sedang mengunduh file game berukuran besar di laptop. Apakah komputer tahu di putaran detik ke berapa unduhan itu akan selesai? Tentu tidak, kan? Komputer hanya tahu satu aturan: “Selama (while) indikator unduhan belum menyentuh 100%, terus lakukan download!”

Nah, perulangan yang jumlah putarannya tidak pasti dan sangat bergantung pada suatu kondisi inilah yang dinamakan Perulangan Bersyarat (While-Loop).

Menyulap for Menjadi While-Loop

Di bahasa pemrograman lain, kamu mungkin harus mengetik kata kunci while(kondisi). Tapi di Go, kita cukup menggunakan kata kunci for lama kita, lalu membuang bagian inisialisasi variabel di depan dan bagian increment (i++) di belakang.

Kita hanya menyisakan satu hal saja di dalam baris for: Kondisi syaratnya!

Struktur kodenya berubah menjadi sangat minimalis seperti ini:

for kondisi {
    // Jalankan kode ini terus-menerus SELAMA kondisi bernilai TRUE
}

Biar tidak bingung, mari kita buat sebuah analogi sederhana. Bayangkan kamu sedang berada di toko buku. Di dompetmu hanya ada uang Rp50.000, tapi kamu naksir berat sama sebuah buku pemrograman seharga Rp120.000. Kamu pun memutuskan untuk menawar dan meminta diskon secara bertahap kepada kasir sampai harganya pas dengan uang di dompetmu.

Mari kita terjemahkan logika tersebut ke dalam kode Go:

package main

import "fmt"

func main() {
    dompet := 50000
    hargaBuku := 120000

    fmt.Println("Aduh, uang di dompet gak cukup buat beli buku...")

    // SELAMA harga buku masih lebih mahal dari uang di dompet, lakukan tawar-menawar!
    for hargaBuku > dompet {
        hargaBuku -= 15000 // Harga dipotong Rp15.000 setiap kali menawar
        fmt.Printf("Minta diskon! Harga buku turun jadi: Rp%d\n", hargaBuku)
    }

    fmt.Println("Asyik, harganya sudah pas. Bukunya akhirnya kebeli!")
}

Cara Komputer Membaca Kode di Atas:

1. Pengecekan Awal: Sebelum masuk ke dalam kurung kurawal for, komputer bertanya dulu: “Apakah hargaBuku > dompet (120.000 > 50.000)?” Jawabannya true (benar). Maka komputer masuk dan menjalankan perintah potong harga.

2. Perulangan Berlanjut: Harga buku sekarang menjadi Rp105.000. Komputer kembali mengecek ke atas. Apakah masih lebih besar dari 50.000? Masih true! Harga dipotong lagi menjadi Rp90.000, lalu Rp75.000, Rp60.000, hingga akhirnya menyentuh angka Rp45.000.

3. Looping Berhenti: Ketika harga buku sudah Rp45.000, komputer mengecek lagi ke atas: “Apakah 45.000 > 50.000?” Jawabannya sekarang adalah false (salah)! Karena kondisinya sudah tidak terpenuhi, komputer langsung melompat keluar dari blok for dan mencetak kalimat “Bukunya akhirnya kebeli!”.

Trik Mengakali “Repeat-Until” (Do-While) di Go-lang

Sekarang, bayangkan kasus kedua: Kamu ingin membuat sebuah game tebak angka sederhana. Program akan meminta pemain untuk memasukkan angka tebakan, lalu mengecek apakah tebakan tersebut benar atau salah.

Pada kasus ini, bisakah kita mengecek tebakan pemain sebelum dia sempat mengetikkan angkanya? Tentu tidak bisa, bukan? Pemain harus menginput angka minimal satu kali dulu, baru setelah itu program bisa mengecek apakah tebakannya benar atau salah.

Di bahasa pemrograman seperti Pascal atau C++, logika ini biasanya ditangani oleh struktur repeat-until atau do-while. Cara kerjanya terbalik dengan While-Loop:

• While-Loop: Cek kondisi dulu ➡️ Baru jalankan kode.
• Repeat-Until (Do-While): Jalankan kode dulu minimal sekali ➡️ Baru cek kondisi di akhir.

Lalu, bagaimana cara kita menerapkannya di Go-lang yang super minimalis ini?

Trik Rahasia: Menggabungkan for Tanpa Henti dan break

Karena Go-lang tidak menyediakan kata kunci do atau repeat, para programmer Go menggunakan trik cerdik: membuat perulangan tanpa henti (infinite loop) menggunakan for {} kosong, lalu meletakkan kondisi berhenti di dalam blok perulangan tersebut menggunakan bantuan if dan kata kunci break.

Struktur dasarnya seperti ini:

for {
    // 1. Jalankan kode kamu di sini (pasti jalan minimal sekali!)
    
    // 2. Cek kondisi berhenti di bawah
    if kondisi_untuk_berhenti {
        break // Keluar paksa dari looping
    }
}

Biar langsung paham, mari kita buat game tebak angka tersebut ke dalam kode Go sesungguhnya:

package main

import "fmt"

func main() {
    angkaRahasia := 7
    var tebakan int

    fmt.Println("=== GAME TEBAK ANGKA RAHASIA ===")

    // Memulai perulangan tanpa henti (seolah-olah 'do')
    for {
        fmt.Print("Masukkan tebakanmu (1-10): ")
        fmt.Scan(&tebakan) // Membaca input dari keyboard

        // Cek kondisi di bagian akhir (seolah-olah 'until')
        if tebakan == angkaRahasia {
            fmt.Println("Keren! Tebakanmu tepat sekali.")
            break // Perulangan berhenti dan keluar dari blok 'for'
        }

        fmt.Println("Yah, masih salah. Coba tebak lagi!")
        fmt.Println("--------------------------------")
    }

    fmt.Println("Terima kasih sudah bermain!")
}

Cara Komputer Membaca Kode Tebak Angka:

1. Jalan Tanpa Syarat: Komputer melihat keyword for tanpa kondisi apa pun. Komputer langsung masuk ke dalam kurung kurawal dan menjalankan perintah fmt.Scan(&tebakan) untuk meminta input dari pemain.

2. Evaluasi di Akhir: Misalkan pemain memasukkan angka 5. Komputer mengecek kondisi if tebakan == angkaRahasia (apakah 5 == 7?). Karena hasilnya false, komputer mengabaikan perintah break, mencetak “Yah, masih salah…”, lalu otomatis memutar kembali perulangan ke atas.

3. Pemberhentian Paksa: Saat pemain akhirnya memasukkan angka 7, komputer mengecek kembali: apakah 7 == 7? Hasilnya true! Komputer langsung mengeksekusi keyword break yang seketika itu juga menghancurkan perulangan dan melompat ke baris paling bawah program.

Ringkasan Cepat: Pilih Senjata yang Tepat!

Agar kamu tidak bingung menentukan kapan harus menggunakan perulangan biasa, While-Loop, atau Repeat-Until di dunia nyata maupun saat praktikum, mari kita lihat tabel rangkuman berikut:

Kesimpulan

Meskipun Go-lang terlihat sangat pelit karena hanya menyediakan satu kata kunci for untuk urusan perulangan, kesederhanaan ini justru membuat kode program kita menjadi sangat konsisten. Kita tidak perlu pusing memikirkan sintaks yang berbeda-beda; cukup gunakan satu keyword for dan modifikasi kondisinya sesuai kebutuhan logika program kita.

Sekarang, kamu sudah menguasai seluruh variasi kontrol perulangan di Go-lang dari yang paling dasar hingga perulangan bersyarat yang dinamis!

🎯 Tantangan Untukmu (Challenge!)

Cobalah buka kembali kode program Game Tebak Angka di atas, lalu modifikasi kodenya agar pemain maksimal hanya memiliki 3 kali kesempatan untuk menebak. Jika 3 kali salah, program akan langsung berhenti dan mencetak “Game Over!”.

Tulis jawaban atau kesulitanmu di kolom komentar di bawah, ya!

Di artikel berikutnya (Artikel #10), kita akan mulai mempelajari topik yang tidak kalah seru untuk membuat logika programmu jauh lebih kompleks dan bertenaga, yaitu Menguasai Komposisi Struktur Kontrol (Nested Loop).

Sudah siap untuk naik level lagi? Sampai jumpa di artikel selanjutnya, dan tetap semangat untuk keep coding!