Vòng lặp for trong Golang: cả bốn dạng kèm ví dụ

Go có đúng một từ khóa vòng lặp (loop): for. Nó có bốn dạng, và cùng nhau chúng thay thế mọi vòng lặp bạn vẫn viết bằng for, while, do while hay foreach ở các ngôn ngữ khác.

package main

import "fmt"

func main() {
	// 1. three-clause loop
	for i := 0; i < 3; i++ {
		fmt.Println("count", i)
	}

	// 2. condition only (a while loop)
	n := 20
	for n > 1 {
		n /= 2
	}
	fmt.Println("n ended at", n)

	// 3. infinite loop with break
	tries := 0
	for {
		tries++
		if tries == 4 {
			break
		}
	}
	fmt.Println("tries:", tries)

	// 4. range
	for i, fruit := range []string{"apple", "kiwi"} {
		fmt.Println(i, fruit)
	}
}

Phần đầu vòng lặp không có dấu ngoặc tròn, và dấu ngoặc nhọn luôn bắt buộc.

Vòng lặp ba mệnh đề

for init; condition; post {
	// body
}

1. init chạy một lần trước vòng lặp. Thường đây là một khai báo biến ngắn như i := 0, và biến đó chỉ tồn tại bên trong vòng lặp.
2. condition được kiểm tra trước mỗi lần lặp. Khi nó sai, vòng lặp kết thúc.
3. Phần thân được thực thi.
4. post chạy sau mỗi lần lặp, thường là i++.

package main

import "fmt"

func main() {
	// count down
	for i := 5; i > 0; i-- {
		fmt.Print(i, " ")
	}
	fmt.Println("liftoff")

	// step by 10
	for x := 0; x <= 50; x += 10 {
		fmt.Print(x, " ")
	}
	fmt.Println()

	// two variables at once (parallel assignment in post)
	word := []rune("racecar")
	isPalindrome := true
	for i, j := 0, len(word)-1; i < j; i, j = i+1, j-1 {
		if word[i] != word[j] {
			isPalindrome = false
			break
		}
	}
	fmt.Println("racecar is a palindrome:", isPalindrome)
}

Trong Go, i++ là một câu lệnh chứ không phải biểu thức, nên post không thể chứa i++, j--. Hãy dùng phép gán song song: i, j = i+1, j-1.

Cả ba mệnh đề đều không bắt buộc. for ; i < 10; {} là hợp lệ, và gofmt sẽ viết lại nó thành for i < 10 {}, chính là dạng tiếp theo.

Vòng lặp chỉ có điều kiện (while của Go)

Chỉ với một điều kiện, for hoạt động như while ở các ngôn ngữ khác:

package main

import "fmt"

func main() {
	// Collatz sequence: how many steps to reach 1?
	n, steps := 27, 0
	for n != 1 {
		if n%2 == 0 {
			n /= 2
		} else {
			n = 3*n + 1
		}
		steps++
	}
	fmt.Println("steps:", steps)
}

Go không có do while riêng. Trang vòng lặp while hướng dẫn cách đạt được hành vi "chạy ít nhất một lần".

Vòng lặp vô hạn

for không có gì phía sau sẽ lặp mãi mãi. Thoát ra bằng break, return, os.Exit hoặc một panic:

for {
	line, err := reader.ReadString('\n')
	if err != nil {
		break
	}
	process(line)
}

Đây là cấu trúc chuẩn cho server, worker và vòng lặp đọc đầu vào. Một for {} với phần thân rỗng sẽ chiếm trọn một lõi CPU; trong code thực tế, phần thân sẽ chờ một thứ gì đó (một lần đọc, một lần nhận từ channel, một select).

Vòng lặp range

range duyệt qua một tập hợp và trả về một hoặc hai giá trị mỗi lần lặp. Đó là giá trị gì phụ thuộc vào thứ bạn duyệt:

package main

import (
	"fmt"
	"maps"
	"slices"
)

func main() {
	nums := []int{10, 20, 30}
	for i, v := range nums {
		fmt.Printf("nums[%d] = %d\n", i, v)
	}

	// only values: discard the index with _
	sum := 0
	for _, v := range nums {
		sum += v
	}
	fmt.Println("sum:", sum)

	// only indexes: omit the second variable
	for i := range nums {
		nums[i] *= 2
	}
	fmt.Println(nums)

	// a string yields runes
	for i, r := range "héllo" {
		fmt.Print(i, ":", string(r), " ")
	}
	fmt.Println()

	// a map yields keys and values in random order, so sort the keys
	ages := map[string]int{"Ben": 25, "Ana": 31, "Chen": 28}
	for _, name := range slices.Sorted(maps.Keys(ages)) {
		fmt.Println(name, ages[name])
	}

	// an integer (Go 1.22)
	for i := range 3 {
		fmt.Print(i, " ")
	}
	fmt.Println()
}

Đầu ra cho thấy ba chi tiết:

• Biến giá trị là một bản sao. v *= 2 bên trong vòng lặp sẽ không thay đổi slice; để sửa phần tử, hãy truy cập slice qua chỉ số với nums[i], như vòng lặp thứ ba.
• Chỉ số của chuỗi là vị trí theo byte. é chiếm hai byte, nên chỉ số nhảy từ 1 lên 3.
• Thứ tự của map là ngẫu nhiên có chủ ý. Go xáo trộn nó để code không thể phụ thuộc vào thứ tự. slices.Sorted(maps.Keys(m)) (Go 1.23) trả về các khóa theo thứ tự.

range được trình bày đầy đủ, bao gồm channel, hàm iterator và các quy tắc sao chép, ở trang range.

break và continue

break kết thúc vòng lặp trong cùng. continue bỏ qua phần còn lại để sang lần lặp tiếp theo (trong vòng lặp ba mệnh đề, post được chạy trước):

package main

import "fmt"

func main() {
	for i := range 10 {
		if i%2 == 0 {
			continue // skip even numbers
		}
		if i > 7 {
			break // stop entirely
		}
		fmt.Print(i, " ")
	}
	fmt.Println()
}

break và continue có nhãn

Một break thông thường chỉ thoát khỏi vòng lặp trong cùng. Để thoát khỏi vòng lặp ngoài từ bên trong một vòng lặp lồng nhau, hãy gắn nhãn cho vòng lặp ngoài:

package main

import "fmt"

func main() {
	grid := [][]int{
		{1, 2, 3},
		{4, 42, 6},
		{7, 8, 9},
	}

	target := 42
	found := false

search:
	for r, row := range grid {
		for c, v := range row {
			if v == target {
				fmt.Printf("found %d at row %d, col %d\n", target, r, c)
				found = true
				break search
			}
		}
	}
	fmt.Println("found:", found)

	// continue with a label skips to the outer loop's next iteration
rows:
	for _, row := range grid {
		for _, v := range row {
			if v%2 == 0 {
				fmt.Println("row with first even number", v)
				continue rows
			}
		}
	}
}

Nhãn là một định danh theo sau bởi dấu hai chấm, đặt ngay trước for. Go báo lỗi biên dịch với nhãn không được dùng, giống như với biến không được dùng.

break bên trong switch và select

Bên trong một for, break trong một case của switch hoặc select sẽ thoát khỏi switch hoặc select, không phải vòng lặp:

for {
	switch cmd := next(); cmd {
	case "quit":
		break // only exits the switch; the loop keeps running
	}
}

Hãy dùng break có nhãn, hoặc return, để thoát khỏi vòng lặp từ bên trong một switch hoặc select.

Biến vòng lặp từ Go 1.22

Go 1.22 đã thay đổi phạm vi của biến vòng lặp: giờ đây mỗi lần lặp có một bản sao mới của i và v. Trước đây, một biến duy nhất được dùng lại cho cả vòng lặp, làm hỏng các closure và goroutine bắt giữ nó:

package main

import (
	"fmt"
	"sync"
)

func main() {
	var funcs []func()
	for i := range 3 {
		funcs = append(funcs, func() { fmt.Print(i, " ") })
	}
	for _, f := range funcs {
		f()
	}
	fmt.Println()

	var wg sync.WaitGroup
	results := make([]string, 3)
	for i, name := range []string{"a", "b", "c"} {
		wg.Add(1)
		go func() {
			defer wg.Done()
			results[i] = name + name
		}()
	}
	wg.Wait()
	fmt.Println(results)
}

Với Go 1.22 trở lên, chương trình này in ra 0 1 2 và [aa bb cc]. Theo ngữ nghĩa cũ, cùng chương trình viết bằng for i := 0; i < 3; i++ (range trên số nguyên chưa tồn tại trước 1.22) in ra 3 3 3, và các goroutine tranh chấp (race) trên i và name dùng chung. Cách khắc phục cũ, i := i ở đầu thân vòng lặp, không còn cần thiết.

Hành vi này được chọn theo từng module qua dòng go trong go.mod, không phải theo phiên bản trình biên dịch. Một module vẫn ghi go 1.21 sẽ giữ ngữ nghĩa cũ ngay cả khi được build bằng Go 1.24.

Những lỗi thường gặp

Sửa bản sao. for _, v := range items { v.Count++ } chỉ thay đổi một bản sao. Hãy dùng items[i].Count++, hoặc duyệt qua một slice chứa con trỏ.

Thêm phần tử trong lúc range. range tính slice một lần duy nhất, lúc bắt đầu. Các phần tử được thêm bên trong vòng lặp sẽ không được duyệt, nên vòng lặp vẫn kết thúc, nhưng nó sẽ không thấy các phần tử mới.

Xóa phần tử khỏi slice theo chỉ số trong vòng lặp tiến. Xóa phần tử i sẽ dồn phần còn lại sang trái, nên phần tử kế tiếp bị bỏ qua. Hãy tạo một slice mới, lặp ngược, hoặc dùng slices.DeleteFunc.

Lệch một đơn vị với <=. for i := 0; i <= len(s); i++ đọc s[len(s)] ở lần lặp cuối và panic với index out of range. Hãy dùng <, hoặc tốt hơn, dùng range.

Việc nặng trong điều kiện. Điều kiện được chạy ở mỗi lần lặp. for i := 0; i < expensiveCount(); i++ gọi hàm ở mọi lần lặp; hãy tính giá trị một lần trước vòng lặp.

Dùng số thực làm biến đếm. for x := 0.0; x != 1.0; x += 0.1 không bao giờ kết thúc, vì 0.1 không có biểu diễn nhị phân chính xác. Hãy đếm bằng số nguyên và tính số thực từ đó.

for i := 0; i < 5; i++ {
	fmt.Println(i)
}