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]// 操作}
}

重要注意事项：

值复制：range 迭代返回的是集合元素的副本，修改副本不影响原数据（指针/引用类型除外）

指针处理：

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)}
}