range trong Golang: mọi dạng, giá trị trả về và các bẫy

range là dạng của vòng lặp for dùng để đi qua một tập hợp. Mỗi lần lặp nó cho bạn một hoặc hai giá trị, và đó là những giá trị gì thì tùy vào kiểu mà bạn range:

package main

import "fmt"

func main() {
	for i, s := range []string{"a", "b"} {
		fmt.Println("slice", i, s)
	}
	for i, r := range "hé" {
		fmt.Println("string", i, string(r))
	}
	for k, v := range map[string]int{"x": 1} {
		fmt.Println("map", k, v)
	}
	ch := make(chan int, 2)
	ch <- 10
	ch <- 20
	close(ch)
	for v := range ch {
		fmt.Println("channel", v)
	}
	for i := range 2 {
		fmt.Println("int", i)
	}
}

Chọn những biến bạn nhận

for i, v := range s {}  // both
for i := range s {}     // index (or key) only
for _, v := range s {}  // value only
for range s {}          // neither: just repeat len(s) times

Khai báo một biến mà không dùng là lỗi biên dịch, nên hãy bỏ hoặc thay bằng _ những biến bạn không cần. for range 3 {} là cách ngắn nhất để lặp lại một việc ba lần.

Giá trị là một bản sao

Ở mỗi lần lặp, phần tử được sao chép vào biến giá trị. Thay đổi biến đó không làm thay đổi tập hợp:

package main

import "fmt"

type Item struct {
	Name  string
	Price int
}

func main() {
	items := []Item{{"pen", 3}, {"book", 12}}

	for _, it := range items {
		it.Price *= 2 // changes the copy
	}
	fmt.Println(items)

	for i := range items {
		items[i].Price *= 2 // changes the element
	}
	fmt.Println(items)

	ptrs := []*Item{{"cup", 5}}
	for _, p := range ptrs {
		p.Price = 1 // p is a copy of the pointer, but points at the real Item
	}
	fmt.Println(*ptrs[0])
}

Sao chép cũng tốn thời gian khi phần tử là struct lớn. Với slice chứa struct lớn, for i := range s kết hợp s[i] sẽ tránh được việc sao chép.

Chuỗi trả về rune

Range trên chuỗi sẽ giải mã UTF-8. Giá trị thứ nhất là vị trí byte nơi mỗi ký tự bắt đầu, nên có thể nhảy cóc số:

package main

import "fmt"

func main() {
	for i, r := range "añ語!" {
		fmt.Printf("byte %d: %c (U+%04X)\n", i, r, r)
	}

	// invalid UTF-8 yields U+FFFD and advances one byte
	for i, r := range "a\xffb" {
		fmt.Printf("byte %d: %q\n", i, r)
	}
}

Để đi qua từng byte thay vì từng ký tự, hãy dùng vòng lặp theo chỉ số, for i := 0; i < len(s); i++, hoặc range trên []byte(s). Xem trang rune và byte để biết chi tiết về UTF-8.

Map: thứ tự ngẫu nhiên

Thứ tự duyệt map không được quy định, và runtime cố ý xáo trộn nó để code không thể dựa vào một thứ tự nào. Muốn đầu ra cố định, hãy sắp xếp các khóa:

package main

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

func main() {
	stock := map[string]int{"pears": 4, "apples": 10, "figs": 0}

	for _, k := range slices.Sorted(maps.Keys(stock)) {
		fmt.Println(k, stock[k])
	}

	// deleting during iteration is allowed
	for k, v := range stock {
		if v == 0 {
			delete(stock, k)
		}
	}
	fmt.Println(len(stock), stock)
}

Xóa phần tử trong lúc range là an toàn, và một phần tử bị xóa khi chưa được duyệt tới sẽ không xuất hiện. Thêm phần tử thì được phép nhưng khó đoán: một khóa mới có thể xuất hiện hoặc không ở phần sau của cùng vòng lặp. fmt.Println in map với các khóa đã sắp xếp, đó là lý do dòng cuối luôn ổn định.

Channel: cho đến khi bị đóng

Range trên channel nhận giá trị cho đến khi channel bị đóng và đã được lấy hết. Nếu không ai đóng nó, vòng lặp bị chặn mãi mãi (và nếu mọi goroutine đều bị chặn, runtime dừng lại với fatal error: all goroutines are asleep - deadlock!):

package main

import "fmt"

func produce(n int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out) // without this, the range below never ends
		for i := range n {
			out <- i * i
		}
	}()
	return out
}

func main() {
	for sq := range produce(5) {
		fmt.Print(sq, " ")
	}
	fmt.Println()
}

Bên gửi đóng channel, không bao giờ là bên nhận. Xem trang channel để biết về channel có bộ đệm và select.

Số nguyên (Go 1.22)

range n đếm từ 0 lên đến n, không bao gồm n. Kiểu của biến vòng lặp là kiểu của n:

for i := range 3 {}         // i is int: 0, 1, 2
for i := range uint8(3) {}  // i is uint8
for range 0 {}              // runs zero times

Với n âm, vòng lặp cũng chạy không lần nào. n được tính một lần, trước khi vòng lặp bắt đầu.

range tính toán những gì, và khi nào

Biểu thức sau range được tính một lần, trước lần lặp đầu tiên. Với slice, range sau đó dùng phần header của slice đó, nên độ dài của nó cố định:

package main

import "fmt"

func main() {
	nums := []int{1, 2, 3}
	for i, v := range nums {
		if i == 0 {
			nums[2] = 30            // visited: same backing array
			nums = append(nums, 99) // not visited
		}
		fmt.Print(v, " ")
	}
	fmt.Println()
	fmt.Println(nums)

	arr := [3]int{1, 2, 3}
	for i, v := range arr { // the array itself is copied
		if i == 0 {
			arr[2] = 30
		}
		fmt.Print(v, " ")
	}
	fmt.Println()
}

Giá trị 99 được append vào không bao giờ được duyệt tới, vì độ dài vòng lặp đã cố định ở 3. Nhưng nums[2] = 30 thì được thấy, vì lúc đó nums vẫn dùng chung mảng nền với slice đang được range. Đổi chỗ hai dòng đó thì giá trị 30 cũng biến mất: append vượt quá dung lượng 3, cấp phát một mảng mới, và lần ghi rơi vào mảng mới đó. Range trên một giá trị mảng sẽ sao chép toàn bộ mảng trước, nên thay đổi ở arr[2] không được thấy; hãy range trên &arr hoặc arr[:] để tránh việc sao chép.

Range trên hàm (Go 1.23)

Từ Go 1.23, range còn nhận cả hàm iterator. Một iterator nhận callback yield, gọi nó một lần cho mỗi giá trị, và dừng khi yield trả về false (điều này xảy ra khi thân vòng lặp chạy break hoặc return):

package main

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

// Countdown yields n, n-1, ..., 1.
func Countdown(n int) iter.Seq[int] {
	return func(yield func(int) bool) {
		for i := n; i > 0; i-- {
			if !yield(i) {
				return
			}
		}
	}
}

// Pairs yields adjacent pairs from a slice.
func Pairs(s []string) iter.Seq2[string, string] {
	return func(yield func(string, string) bool) {
		for i := 0; i+1 < len(s); i++ {
			if !yield(s[i], s[i+1]) {
				return
			}
		}
	}
}

func main() {
	for n := range Countdown(5) {
		if n == 2 {
			break // yield returns false, Countdown stops
		}
		fmt.Print(n, " ")
	}
	fmt.Println()

	for a, b := range Pairs([]string{"a", "b", "c"}) {
		fmt.Println(a, "->", b)
	}

	// standard library iterators
	for i, v := range slices.Backward([]string{"x", "y", "z"}) {
		fmt.Printf("%d:%s ", i, v)
	}
	fmt.Println()
	fmt.Println(slices.Sorted(maps.Values(map[string]int{"a": 3, "b": 1})))
}

iter.Seq[V] và iter.Seq2[K, V] là tên chuẩn cho hai dạng iterator. Thư viện chuẩn trả về chúng từ slices.All, slices.Values, slices.Backward, maps.Keys, maps.Values, maps.All, và trong Go 1.24 từ strings.SplitSeq, strings.Lines và bytes.SplitSeq. Iterator phải tôn trọng giá trị trả về của yield: gọi yield thêm lần nữa sau khi nó đã trả về false sẽ gây panic.

Biến vòng lặp riêng cho từng lần lặp (Go 1.22)

Từ Go 1.22, các biến do for ... range khai báo là biến mới ở mỗi lần lặp. Bắt v trong một closure hay goroutine sẽ bắt giá trị của lần lặp đó, chứ không phải một biến dùng chung mà cuối cùng giữ phần tử cuối cùng. Trước Go 1.22 bạn cần viết v := v bên trong vòng lặp; dòng đó giờ là thừa. Quy tắc này được quyết định bởi phiên bản go trong go.mod, nên một module cũ vẫn giữ hành vi cũ.

Lỗi thường gặp

• Lấy địa chỉ của biến giá trị. Trước Go 1.22, ptrs = append(ptrs, &v) lưu cùng một địa chỉ ở mọi lần lặp. Từ 1.22 nó lưu các địa chỉ khác nhau, nhưng mỗi địa chỉ trỏ tới một bản sao, không phải phần tử trong slice. Hãy dùng &items[i] để trỏ vào slice.
• Trông chờ thứ tự của map. Đầu ra trông như đã sắp xếp trong một test nhỏ sẽ không giữ được thứ tự đó mãi.
• Range trên channel mà không ai đóng. Vòng lặp, và cả goroutine đang chạy nó, sẽ chờ mãi mãi.
• Range trên một mảng lớn theo giá trị. Toàn bộ mảng bị sao chép trước. Hãy range trên một slice của nó.