While Loop di Golang: Cara Menulis while dan do-while di Go

Go tidak punya kata kunci while. Tulis for diikuti sebuah kondisi, dan kamu sudah punya while loop:

package main

import "fmt"

func main() {
	balance := 1000.0
	years := 0

	for balance < 2000 {
		balance *= 1.07
		years++
	}

	fmt.Printf("doubled after %d years: %.2f\n", years, balance)
}

Kondisinya diperiksa sebelum setiap iterasi, jadi kalau kondisinya false sejak awal, badan perulangan tidak pernah dijalankan. Ini sama persis dengan while (balance < 2000) di C, Java, atau JavaScript, hanya tanpa tanda kurung dan kata kuncinya. Para perancang Go memilih satu kata kunci untuk semua bentuk perulangan; lihat halaman for loop untuk keempat bentuknya.

while(true): perulangan tanpa akhir

Hilangkan kondisinya sama sekali, dan perulangan akan berjalan sampai ada sesuatu di dalamnya yang mengakhirinya:

package main

import "fmt"

func main() {
	queue := []string{"email", "resize", "stop", "never-reached"}

	for {
		job := queue[0]
		queue = queue[1:]

		if job == "stop" {
			fmt.Println("stopping")
			break
		}
		fmt.Println("processing", job)
	}

	fmt.Println("left in queue:", queue)
}

for { } adalah cara penulisan yang idiomatis. for true { } juga bisa dikompilasi, tetapi terbaca seolah penulisnya berasal dari bahasa lain.

Ada empat hal yang mengakhiri perulangan tanpa akhir: break (keluar dari perulangan), return (keluar dari fungsi), panic, dan os.Exit. Program yang main-nya berada di for {} tanpa satu pun dari keempatnya akan berjalan sampai dihentikan paksa, dan itu memang yang tepat untuk sebuah server atau worker.

do-while

do-while menjalankan badan perulangan sekali sebelum memeriksa kondisinya. Go tidak punya sintaks khusus untuk ini. Taruh pemeriksaannya di akhir perulangan tanpa akhir:

package main

import (
	"fmt"
	"math/rand/v2"
)

func main() {
	r := rand.New(rand.NewPCG(8, 8))

	rolls := 0
	for {
		roll := r.IntN(6) + 1
		rolls++
		fmt.Println("rolled", roll)

		if roll == 6 {
			break
		}
	}
	fmt.Println("needed", rolls, "rolls to get a 6")
}

Badan perulangan dijalankan minimal sekali apa pun yang terjadi, dan itulah ciri utama do-while. Sumber angka acaknya memakai seed tetap sehingga output-nya sama di setiap run; pakai rand.IntN tanpa sumber yang diberi seed untuk keacakan sungguhan.

Bentuk kedua menjaga kondisinya tetap di header dengan memaksa putaran pertama:

for first := true; first || condition(); first = false {
	// body
}

Cara ini bisa dipakai, tetapi perulangan tanpa akhir dengan break di akhir lebih mudah dibaca, dan itulah yang dilakukan sebagian besar kode Go.

Membaca sampai selesai

While loop yang paling umum di kode Go sungguhan adalah membaca input sampai habis. bufio.Scanner dirancang untuk itu: Scan mengembalikan false di akhir input atau saat terjadi error, jadi fungsi itulah kondisi perulangannya:

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	input := "first line\nsecond line\nthird line\n"
	scanner := bufio.NewScanner(strings.NewReader(input))

	n := 0
	for scanner.Scan() {
		n++
		fmt.Printf("%d: %s\n", n, scanner.Text())
	}
	if err := scanner.Err(); err != nil {
		fmt.Println("read error:", err)
	}
}

Ganti strings.NewReader(input) dengan os.Stdin, dan perulangan yang sama akan membaca input pengguna baris demi baris. Periksa scanner.Err() setelah perulangan: Scan yang mengembalikan false tidak memberi tahu apakah input berakhir normal atau gagal.

break dan continue

Keduanya bisa dipakai di semua bentuk for:

package main

import "fmt"

func main() {
	n := 0
	for n < 20 {
		n++
		if n%3 != 0 {
			continue // back to the condition check
		}
		if n > 12 {
			break
		}
		fmt.Print(n, " ")
	}
	fmt.Println()
}

Di perulangan yang hanya berisi kondisi, continue langsung melompat ke pemeriksaan kondisi. Ini memudahkan munculnya bug yang halus: kalau penghitung diperbarui di bagian bawah badan perulangan, continue di atasnya akan melewati pembaruan itu dan perulangannya tidak pernah berakhir. Perbarui penghitung di bagian atas, seperti di atas, atau pakai for tiga klausa yang pernyataan post-nya tetap dijalankan setelah continue.

Menunggu sesuatu

Perulangan yang menunggu sebuah kondisi sebaiknya memblokir atau tidur, bukan berputar terus:

// Wrong: burns a CPU core while waiting
for !ready {
}

// Better: poll with a delay
for !isReady() {
	time.Sleep(100 * time.Millisecond)
}

Memeriksa berulang-ulang variabel biasa yang ditulis goroutine lain juga merupakan data race. Antar-goroutine, tunggulah di channel, sync.WaitGroup, atau sync.Cond, atau pakai select dengan timer. Untuk perulangan percobaan ulang yang punya batas, lebih baik pakai for dengan penghitung agar perulangannya tidak bisa berjalan selamanya:

for attempt := 1; attempt <= 5; attempt++ {
	if err := connect(); err == nil {
		break
	}
	time.Sleep(time.Duration(attempt) * 200 * time.Millisecond)
}

Kesalahan umum

• Lupa mengubah variabel kondisi. for i < 10 { fmt.Println(i) } tidak pernah berakhir. Setiap while loop butuh sesuatu di badannya yang menggerakkannya menuju titik keluar.
• Menulis while. while x < 5 {} menghasilkan syntax error: unexpected name x at end of statement, karena while bukan kata kunci; compiler membacanya sebagai nama biasa.
• Tanda kurung karena kebiasaan. for (x < 5) {} bisa dikompilasi, dan gofmt akan menghapus tanda kurungnya.
• Mendeklarasikan variabel di dalam perulangan. for n := 10; n > 0 {} adalah syntax error; perulangan dengan klausa init butuh ketiga klausanya. Deklarasikan n sebelum perulangan, atau tulis bentuk tiga klausa yang lengkap.

for count < 10 {
	count++
}

for {
	// body runs at least once
	if !condition {
		break
	}
}