Golang — break, continue, goto (dan Kapan Sebaiknya Dihindari)

Kalau kamu sudah masuk dunia Golang, pasti cepat atau lambat bakal ketemu tiga kata sakti ini: break, continue, dan goto. Sekilas kelihatannya simpel kayak tombol skip intro di Netflix tapi kalau salah pakai, bisa bikin kode kamu berasa kayak labirin Minotaur: bikin pusing, bingung, dan ingin pensiun dini dari dunia IT.

Di artikel ini kita akan bahas semuanya dengan santai, contoh nyata, plus kapan sebenarnya mereka boleh dipakai, dan kapan sebaiknya kamu pura-pura lupa kalau fitur itu ada. Let’s go!

 

Apa Itu break?

Kalau kamu sedang loop dan tiba-tiba berpikir, “Aduh, udah cukup deh,” maka jawabannya adalah break. Keyword ini buat menghentikan loop lebih cepat.

Contoh sederhana:

for i := 1; i <= 10; i++ {
    if i == 5 {
        break
    }
    fmt.Println(i)
}

Output:

1
2
3
4

Begitu i == 5, loop langsung disuruh bubar barisan.

Kapan break bagus dipakai?

• Saat kamu mencari sesuatu di sebuah loop.

• Saat ada kondisi darurat (contoh: data tidak valid → hentikan pemrosesan).

• Saat kamu mendeteksi situasi yang tidak perlu dilanjutkan lagi.

Kapan sebaiknya hati-hati?

• Kalau kamu punya banyak nested loop dan cuma break satu tingkat. Kadang kamu kira break-nya menghentikan semuanya, ternyata cuma satu loop yang berhenti.

• Kalau sering pakai break sebagai obat semua masalah, berarti ada masalah desain struktur kode.

   

Apa Itu continue?

continue bukan menghentikan loop, tapi bilang ke Golang: “Skip bagian ini, langsung lanjut iterasi berikutnya, bray.”

Contoh penggunaan:

for i := 1; i <= 10; i++ {
    if i%2 == 0 {
        continue
    }
    fmt.Println(i)
}

Output:

1
3
5
7
9

Angka genap dilewatkan.

Kapan continue berguna?

• Saat kamu ingin melewatkan kondisi tertentu (misalnya invalid data).

• Saat kamu ingin mengurangi if bersarang yang tak perlu.

• Saat kamu mau memperjelas alur: “Kalau kondisi A, skip saja.”

Kapan hati-hati?

• Kalau penggunaan continue membuat logika jadi susah dibaca, terutama dalam loop kompleks.

• Kalau kamu pakai continue berlapis-lapis sampai bikin programmer lain curiga kamu sedang balas dendam ke mereka.

   

Apa Itu goto?

Nah, ini dia keyword paling kontroversial.

goto basically bilang ke Golang: “Loncat ke label itu!”
Dan Golang jawab: “Siap, bos!”

Secara formal, goto adalah perintah untuk melompat ke posisi tertentu dalam kode dengan menggunakan label.

Contoh:

i := 1

start:
    if i <= 5 {
        fmt.Println(i)
        i++
        goto start
    }

Output:

1
2
3
4
5

Apakah ini bisa dilakukan tanpa goto?
Tentu bisa. 99% waktu, seharusnya dilakukan tanpa goto.
Karena wujud kode seperti di atas membuat developer lain nanya:

“Ini loop zaman prasejarah siapa yang nulis?”

Kapan goto boleh dipakai?

Jujur, jarang. Sangat jarang.
Tapi masih ada kasus sah:

1. Membersihkan resources sebelum return (mirip pattern err: di C).
   Golang punya defer, jadi sebenernya goto jarang dibutuhkan untuk ini.

2. Keluar cepat dari nested loop yang dalam.
   break hanya bisa keluar satu tingkat.
   Kalau kamu punya 3-4 nested loop, pakai goto bisa mengurangi kompleksitas.

3. Implementasi state machine tertentu, tapi tetap jarang dan butuh kehati-hatian super.

Kapan HARUS dihindari?

• Kalau logika jadi seperti mie instan kuah tumpah: berantakan, sulit diikuti.

• Kalau ada cara lain yang lebih rapi (90% ada).

• Kalau kamu programmer normal. (Just kidding… probably)

• Kalau kamu tidak suka ditelepon malam-malam oleh rekan tim hanya untuk menjelaskan kenapa alurnya “lompat-lompat kayak kodok”.

   

Perbandingan Singkat

Keyword	Fungsi utama	Risiko
break	Menghentikan loop	Nested loop bisa bikin bingung
continue	Skip satu iterasi	Bisa sembunyikan logika penting
goto	Lompat ke label tertentu	Membuat kode tidak terprediksi

 

Contoh Kasus Dunia Nyata

Mari lihat beberapa skenario nyata (atau hampir nyata):

1. Mencari User Dalam Daftar — pakai break

users := []string{"Budi", "Tono", "Sari", "Agung"}

for _, user := range users {
    if user == "Agung" {
        fmt.Println("User ditemukan:", user)
        break
    }
    fmt.Println("Memeriksa:", user)
}

Simple, jelas, aman.

 

2. Validasi Data — pakai continue

data := []int{10, -3, 20, -1, 30}

for _, d := range data {
    if d < 0 {
        fmt.Println("Data invalid, skip:", d)
        continue
    }
    fmt.Println("Memproses:", d)
}

Alih-alih bikin if panjang, continue bikin flow lebih bersih.

 

3. Keluar dari Nested Loop — Tempat di mana goto masuk akal

Tanpa goto:

found := false
for i := 0; i < 5; i++ {
    for j := 0; j < 5; j++ {
        if i*j == 6 {
            found = true
            break
        }
    }
    if found {
        break
    }
}
fmt.Println("Ditemukan:", found)

Dengan goto lebih rapi:

for i := 0; i < 5; i++ {
    for j := 0; j < 5; j++ {
        if i*j == 6 {
            goto done
        }
    }
}

done:
fmt.Println("Ditemukan!")

Walaupun memakai goto, versi ini justru lebih mudah dipahami daripada ada 2 break + 1 flag variable.

Ini contoh langka yang “masih halal”.

 

Kenapa Banyak Programmer Menyuruh Hindari goto?

Sejarah singkat: zaman dulu (era tahun 1970-an), goto dipakai buat segala hal. Hasilnya? Kode jadi chaos, sulit dipahami, dan penuh bug.

Donald Knuth legenda hidup ilmu komputer bilang bahwa goto tidak selalu buruk, tapi harus dipakai hanya kalau memang benar-benar tepat. Dan sejak Go punya:

• break

• continue

• return

• defer

…maka 99% alasan pakai goto hilang.

 

Jadi, Kapan Sebaiknya Dipakai?

1. break

✔ Dipakai untuk menghentikan loop secara jelas.
✖ Hindari kalau membuat alur sulit dilacak karena nested loops.

2. continue

✔ Dipakai untuk melewatkan kondisi tertentu agar logika bersih.
✖ Hindari kalau terlalu banyak cabang dan kondisi.

3. goto

✔ Hanya untuk kasus sangat spesifik, seperti keluar dari nested loop dalam.
✖ 99% waktu, hindari.
✖ Kalau tujuanmu cuma bikin diri sendiri bingung jangan.

 

Tiga Pemain, Tiga Sifat Berbeda

• break = “Udah cukup, berhenti!”

• continue = “Skip dulu bagian ini.”

• goto = “Loncat ke sana!”

Semua punya tempat, semua punya risiko.
Jangan takut pakai break atau continue, karena mereka memang bagian dari alur kontrol yang wajar. Tapi goto adalah pedang bermata dua, tajam, tapi berbahaya. Kalau kamu tidak benar-benar butuh, lebih baik tinggalkan dia di museum.