Go 語言 range 關鍵字全面解析

range 是 Go 語言中用于迭代數據結構的關鍵字，支持多種數據類型的遍歷操作。它提供了一種簡潔、安全且高效的方式來處理集合類型的數據。

基本語法

for index, value := range collection {// 循環體
}

1. 數組/切片迭代

fruits := []string{"Apple", "Banana", "Cherry"}// 只獲取索引
for i := range fruits {fmt.Printf("Index: %d\n", i)
}// 只獲取值
for _, fruit := range fruits {fmt.Printf("Fruit: %s\n", fruit)
}// 獲取索引和值
for i, fruit := range fruits {fmt.Printf("%d: %s\n", i, fruit)
}

??輸出??:

Index: 0
Index: 1
Index: 2
Fruit: Apple
Fruit: Banana
Fruit: Cherry
0: Apple
1: Banana
2: Cherry

2. 映射(Map)迭代

ages := map[string]int{"Alice": 25,"Bob":   30,"Eve":   28,
}// 迭代鍵值對
for name, age := range ages {fmt.Printf("%s is %d years old\n", name, age)
}// 只迭代鍵
for name := range ages {fmt.Println("Name:", name)
}// 只迭代值
for _, age := range ages {fmt.Println("Age:", age)
}

??注意??：映射的迭代順序是不確定的，每次運行可能不同

3. 字符串迭代

str := "Go語言"// 按字節迭代（可能不完整處理Unicode字符）
for i, char := range []byte(str) {fmt.Printf("Byte %d: %d\n", i, char)
}// 正確方式：按Rune迭代（處理完整Unicode字符）
for i, char := range str {fmt.Printf("Rune %d: %c (Unicode: U+%04X)\n", i, char, char)
}// 統計字符串的Unicode字符數量
count := 0
for range str {count++
}
fmt.Printf("'%s' has %d runes\n", str, count) // "Go語言" has 4 runes

??輸出??:

Rune 0: G (Unicode: U+0047)
Rune 1: o (Unicode: U+006F)
Rune 2: 語 (Unicode: U+8BED)
Rune 5: 言 (Unicode: U+8A00)

4. 通道(Channel)迭代

func producer(ch chan<- int) {for i := 0; i < 3; i++ {ch <- i * 10}close(ch)
}func main() {ch := make(chan int, 3)go producer(ch)// 通道迭代直到關閉for value := range ch {fmt.Println("Received:", value)}
}

??輸出??:

Received: 0
Received: 10
Received: 20

5. 特殊數據結構迭代

a. 自定義類型迭代器

type IntRange struct {start, end int
}func (r *IntRange) Next() (int, bool) {if r.start >= r.end {return 0, false}value := r.startr.start++return value, true
}func (r *IntRange) Iterate() chan int {ch := make(chan int)go func() {defer close(ch)for value, ok := r.Next(); ok; value, ok = r.Next() {ch <- value}}()return ch
}func main() {r := &IntRange{start: 5, end: 8}for n := range r.Iterate() {fmt.Println(n) // 輸出: 5,6,7}
}

b. 迭代空集合

var empty []int
for i, v := range empty {fmt.Println("This won't run")
}
// 安全，不會出錯

6. 底層原理分析

range 實際上是一種語法糖，編譯時會轉換為普通循環：

// 原始代碼
for i, v := range slice {// 操作
}// 編譯后等效的代碼
{tmpslice := slicefor i := 0; i < len(tmpslice); i++ {v := tmpslice[i]// 操作}
}

重要注意事項：

1. ??值復制??：range 迭代返回的是集合元素的??副本??，修改副本不影響原數據（指針/引用類型除外）
2. ??指針處理??：

   type Point struct{ X, Y int }points := []Point{{1, 2}, {3, 4}}for i, p := range points {// 修改副本不會影響原始數據p.X++ points[i].Y++ // 正確修改原數據的方式
   }

7. 性能優化技巧

a. 避免值復制

// 對于大結構體，避免復制開銷
type BigStruct struct { data [1024]byte }bigSlice := make([]BigStruct, 1000)// 較差的方式：每次迭代復制整個結構體
for _, item := range bigSlice {// item 是副本
}// 推薦方式：按索引訪問
for i := range bigSlice {// 直接操作 bigSlice[i]bigSlice[i].data[0] = 1
}

b. 避免內存分配

// 預分配切片用于結果收集
var results []int
data := []int{1, 2, 3, 4, 5}// 預分配空間
results = make([]int, 0, len(data))
for _, v := range data {results = append(results, v*2)
}

8. 常見問題與解決方案

問題1：修改原始切片失敗

nums := []int{1, 2, 3}
for _, num := range nums {num *= 2 // 無效修改
}

??解決方案??：使用索引

for i := range nums {nums[i] *= 2
}

問題2：goroutine 使用閉包陷阱

for i, v := range []int{10, 20, 30} {go func() {fmt.Println(i, v) // 所有goroutine輸出相同的值}()
}

??解決方案??：通過參數傳遞值

for i, v := range []int{10, 20, 30} {go func(i, v int) {fmt.Println(i, v) // 正確輸出}(i, v)
}

9. 不同數據類型的特性總結

數據類型	返回參數	順序保證	修改影響
??數組??	(index, value)	順序(0→N)	副本修改無效
??切片??	(index, value)	順序(0→N)	副本修改無效
??映射??	(key, value)	隨機	副本修改無效
??字符串??	(index, rune)	順序(0→N)	不可修改
??通道??	(value)	發送順序	N/A

實際應用案例

1. 并行處理切片

func parallelProcess(data []int) []int {results := make([]int, len(data))var wg sync.WaitGroupwg.Add(len(data))for i, v := range data {go func(i, v int) {defer wg.Done()// 執行耗時操作results[i] = v * v}(i, v)}wg.Wait()return results
}

2. 并發安全迭代器

func safeIterate(m map[string]int) {// 創建臨時副本迭代keys := make([]string, 0, len(m))for k := range m {keys = append(keys, k)}for _, k := range keys {v := m[k] // 安全訪問// 處理邏輯}
}

3. 大型文件處理

func processLargeFile(filename string) {file, err := os.Open(filename)if err != nil {log.Fatal(err)}defer file.Close()scanner := bufio.NewScanner(file)for scanner.Scan() {line := scanner.Text()// 逐行處理大文件processLine(line)}if err := scanner.Err(); err != nil {log.Fatal(err)}
}

總結

Go 的 range 關鍵字是處理集合類數據的核心工具：

1. ??簡潔性??：簡化循環語法
2. ??安全性??：正確處理不同類型的邊界情況
3. ??高效性??：編譯優化后性能優秀
4. ??靈活性??：支持多數據類型和值選擇

關鍵使用要點：

• 理解不同數據類型的迭代特性
• 注意值復制行為（尤其是大型結構體）
• 在并發環境中安全使用
• 利用索引優化性能

掌握 range 的深度使用可以極大提高 Go 編程的效率和代碼質量。