在Go语言中，for range是遍历各类集合最常用也最容易被误用的语法结构。它表面简洁，背后却隐藏了值拷贝、迭代器复用变量等细节，理解这些细节是写出正确并发与修改逻辑的前提。
一、for range的基本语法与编译器展开
for range可以作用于array、slice、map、string、channel五种类型。以slice为例，我们写的代码通常如下：
package main
import "fmt"
func main() {
nums := []int{10, 20, 30}
for i, v := range nums {
fmt.Println(i, v)
}
}
在编译阶段，上面的写法会被Go编译器改写为类似下面的传统for循环。关键点在于，迭代变量i和v是在循环外声明、在每次迭代中被重新赋值的，而不是每次都创建新变量。
package main
import "fmt"
func main() {
nums := []int{10, 20, 30}
var i, v int
for_temp := nums
len := len(for_temp)
for index := 0; index < len; index++ {
i = index
v = for_temp[index]
fmt.Println(i, v)
}
}
从展开后的代码能看出，v拿到的是元素的一份拷贝。如果元素是结构体且体积较大，这种拷贝会带来性能开销；同时，修改v不会影响原slice中的值，必须借助下标i回写。
二、遍历slice与array的值拷贝陷阱
很多初学者在遍历slice时尝试直接修改v，结果原数据纹丝不动。下面这段代码就展示了典型错误：
package main
import "fmt"
type User struct {
Name string
Age int
}
func main() {
users := []User{{"Tom", 18}, {"Lucy", 20}}
// 错误写法：修改v不会影响users
for _, v := range users {
v.Age = v.Age + 1
}
fmt.Println(users) // 年龄未变
}
正确的做法是通过下标访问原元素，这样修改才会生效。此外，如果slice中存放的是指针，那么v虽然是指针的拷贝，但指向的仍是同一块内存，此时修改指针指向的内容可以生效。
package main
import "fmt"
type User struct {
Name string
Age int
}
func main() {
users := []User{{"Tom", 18}, {"Lucy", 20}}
// 正确写法：通过下标修改
for i := range users {
users[i].Age = users[i].Age + 1
}
fmt.Println(users) // 年龄已加一
}
array的遍历逻辑与slice一致，但由于array是值类型，在for range表达式中被复制，若array很大则会有明显拷贝成本。通常建议对大array使用指针或slice来避免全量拷贝。
三、遍历map的迭代顺序与删除安全
Go中的map遍历顺序是不确定的，每次运行可能不同，这是故意的设计，用于防止程序依赖特定顺序。下面演示了基本的map遍历：
package main
import "fmt"
func main() {
m := map[string]int{"a": 1, "b": 2, "c": 3}
for k, v := range m {
fmt.Println(k, v)
}
}
在遍历map时删除或新增元素都是安全的，Go运行时会处理迭代器状态。但要注意，如果在遍历中修改value，同样需要回写map，而不能只改v。下面的示例展示了安全删除键的操作：
package main
import "fmt"
func main() {
m := map[string]int{"a": 1, "b": 2, "c": 3}
for k := range m {
if k == "b" {
delete(m, k)
}
}
fmt.Println(m) // 不包含b
}
虽然删除安全，但如果在多线程环境下同时读写同一个map而没有加锁，会触发panic。此时应使用sync.RWMutex或sync.Map来保证并发安全，而不是依赖遍历机制。
四、遍历channel与退出控制
对channel使用for range时，循环会一直阻塞直到channel被关闭，并依次取出所有已发送的值。这一特性非常适合用来接收任务结果。
package main
import "fmt"
func main() {
ch := make(chan int, 3)
ch <- 1
ch <- 2
ch <- 3
close(ch)
for v := range ch {
fmt.Println(v)
}
}
如果channel没有被关闭，for range会永久阻塞在当前goroutine，可能导致死锁。因此在生产者端务必记得close，或者使用select配合done信号来退出循环。下面的写法展示了带退出机制的接收方式：
package main
import (
"fmt"
"time"
)
func main() {
ch := make(chan int)
done := make(chan bool)
go func() {
for i := 0; i < 5; i++ {
ch <- i
time.Sleep(time.Millisecond * 100)
}
close(ch)
}()
go func() {
time.Sleep(time.Second)
done <- true
}()
for {
select {
case v, ok := <-ch:
if !ok {
return
}
fmt.Println(v)
case <-done:
fmt.Println("timeout exit")
return
}
}
}
这种方式比单纯依赖close更灵活，适合需要超时控制或外部中断的消费场景。在真实服务中，结合context.Context做取消信号是更标准的工程做法。
五、并发遍历集合的注意事项
当多个goroutine同时遍历并修改同一集合时，slice本身不是并发安全的，map更是会直接panic。简单做法是加锁，把整个遍历区间保护起来。
package main
import (
"fmt"
"sync"
)
func main() {
m := map[string]int{"x": 1, "y": 2}
var mu sync.RWMutex
var wg sync.WaitGroup
for i := 0; i < 2; i++ {
wg.Add(1)
go func(id int) {
defer wg.Done()
mu.RLock()
for k, v := range m {
fmt.Println(id, k, v)
}
mu.RUnlock()
}(i)
}
wg.Wait()
}
如果读多写少，sync.RWMutex比普通Mutex效率更高；若集合生命周期内只写一次、后续纯读，可在初始化后不再加锁。对于超高并发场景，可考虑分片map或将数据复制到局部slice后再并发处理，从而减少锁竞争。
六、总结建议
for range是Go集合操作的核心语法，其本质是对传统循环的语法糖，并带有迭代变量复用与值拷贝语义。写代码时应牢记：修改元素要走下标或指针，遍历map别依赖顺序，channel记得关闭，并发访问必须加同步。把这些点融入日常编码习惯，就能避开绝大多数遍历相关的隐蔽问题。