for...range 遍历切片/数组时的值拷贝陷阱

Go 语言的 for...range 在遍历切片或数组时，每次迭代都会将元素值拷贝到一个固定的临时变量中。理解这个机制，才能避免修改元素失败、取地址错误、大结构体拷贝等常见陷阱。

目录#

核心机制：值拷贝
陷阱一：修改 value 不会影响原数据
陷阱二：value 的地址始终不变
陷阱三：遍历的是原切片的副本
陷阱四：大结构体的拷贝开销
正确写法总结
Go 1.22 变化：循环变量语义变更

1. 核心机制：值拷贝#

1.1 语法回顾#

Go 的 for...range 有两种常见形式：

1
// 形式一：同时获取索引和值
2
for index, value := range sliceOrArray {
3
    // index: 当前元素的索引
4
    // value: 当前元素的副本
5
}
6

7
// 形式二：只获取索引
8
for index := range sliceOrArray {
9
    // 不复制值，直接通过索引访问
10
}

1.2 底层发生了什么#

1
// 你写的代码：
2
for i, v := range items {
3
    fmt.Println(v)
4
}
5

6
// Go 编译器的等效展开（伪代码）：
7
for i := 0; i < len(items); i++ {
8
    v := items[i]     // ← 每次迭代，将元素拷贝到临时变量 v
9
    fmt.Println(v)
10
}

关键事实：

事实	说明
`v` 是临时变量	整个循环期间只有一块内存，每次迭代覆盖写入
`v` 是元素副本	修改 `v` 不会影响 `items[i]`（基本类型和结构体）
`&v` 始终相同	取 `v` 的地址得到的是同一个临时变量的地址
仅遍历索引不拷贝	`for i := range items` 不会创建值副本

2. 陷阱一：修改 value 不会影响原数据#

问题代码#

1
package main
2

3
import "fmt"
4

5
type User struct {
6
    Name string
7
    Age  int
8
}
9

10
func main() {
11
    users := []User{
12
        {Name: "Alice", Age: 20},
13
        {Name: "Bob",   Age: 25},
14
        {Name: "Carol", Age: 30},
15
    }
16

17
    // ❌ 错误：修改的是副本，原切片不变
18
    for _, u := range users {
19
        u.Age += 1
20
    }
21
    fmt.Println(users)
22
    // 输出: [{Alice 20} {Bob 25} {Carol 30}]  ← 没变
23
}

正确写法#

1
// ✅ 方法一：通过索引直接修改原数据
2
for i := range users {
3
    users[i].Age += 1
4
}
5
fmt.Println(users)
6
// 输出: [{Alice 21} {Bob 26} {Carol 31}]
7

8
// ✅ 方法二：存储指针切片
9
userPtrs := []*User{
10
    {Name: "Alice", Age: 20},
11
    {Name: "Bob",   Age: 25},
12
}
13
for _, u := range userPtrs {
14
    u.Age += 1          // u 是指针，修改指向的值
15
}

建议：需要修改元素时，优先使用 for i := range slice + slice[i] 的方式。

3. 陷阱二：value 的地址始终不变#

问题代码#

1
package main
2

3
import "fmt"
4

5
func main() {
6
    nums := []int{10, 20, 30, 40, 50}
7

8
    var ptrs []*int
9

10
    // ❌ 错误：每次取到的都是同一个临时变量 v 的地址
11
    for _, v := range nums {
12
        ptrs = append(ptrs, &v)
13
    }
14

15
    for _, p := range ptrs {
16
        fmt.Print(*p, " ")
17
    }
18
    // 输出: 50 50 50 50 50  ← 全部是最后一个值！
19
}

原理图解#

1
第 1 次迭代:  v ← 10   →  &v = 0xc00001a080
2
第 2 次迭代:  v ← 20   →  &v = 0xc00001a080   ← 同一地址！
3
第 3 次迭代:  v ← 30   →  &v = 0xc00001a080
4
...
5
循环结束后:  v = 50     →  所有指针都指向 50

正确写法#

1
// ✅ 方法一：通过索引取原元素地址
2
for i := range nums {
3
    ptrs = append(ptrs, &nums[i])
4
}
5
// 输出: 10 20 30 40 50
6

7
// ✅ 方法二：在循环体内创建局部变量再取地址
8
for _, v := range nums {
9
    v := v              // 创建新的局部变量(1.21及之前需要此步骤)
10
    ptrs = append(ptrs, &v)
11
}

4. 陷阱三：遍历的是原切片的副本#

4.1 `for...range` 的求值时机#

1
// for...range 在循环开始前就对表达式求值，生成一个副本
2
for i, v := range expr { ... }
3
//               ~~~~
4
//               这个表达式只求值一次（循环开始前）

这意味着：

1
package main
2

3
import "fmt"
4

5
func main() {
6
    nums := []int{1, 2, 3, 4, 5}
7

8
    for i, v := range nums {
9
        if i == 0 {
10
            nums = append(nums, 6, 7, 8) // 可能触发扩容，指向新底层数组
11
        }
12
        fmt.Println(v)
13
        // v 仍然取自旧切片的副本
14
    }
15
    // 输出: 1 2 3 4 5
16
    // 不会输出 6 7 8，因为 range 使用的是循环开始前的切片副本
17
}

4.2 何时需要关注#

场景	是否有影响
遍历中 `append` 且扩容	`v` 仍取自旧切片副本
遍历中修改元素值（通过切片）	不受影响，切片头副本共享底层数组
遍历中修改切片长度（重新切片）	`v` 仍取自旧副本

5. 陷阱四：大结构体的拷贝开销#

问题场景#

1
type LargeRecord struct {
2
    ID        int64
3
    Data      [4096]byte     // 4KB 数据
4
    Timestamp int64
5
    Metadata  [256]byte
6
    // ... 更多字段，假设总计 5KB
7
}
8

9
records := make([]LargeRecord, 100000)
10

11
// ❌ 差：每次迭代拷贝 5KB，总计 500MB 内存拷贝！
12
for _, r := range records {
13
    process(r)      // r 是 LargeRecord 的副本
14
}

正确写法#

1
// ✅ 方法一：使用索引，避免值拷贝
2
for i := range records {
3
    process(records[i])
4
}
5

6
// ✅ 方法二：使用指针切片
7
recordPtrs := []*LargeRecord{...}
8
for _, r := range recordPtrs {
9
    process(*r)    // r 是指针，只拷贝 8 字节
10
}
11

12
// ✅ 方法三：取地址（如果能直接操作原切片）
13
for i := range records {
14
    process(&records[i])
15
}

Benchmark 验证#

1
package main
2

3
import "testing"
4

5
type BigStruct struct {
6
    data [4096]byte
7
    id   int64
8
}
9

10
var bigSlice = make([]BigStruct, 10000)
11

12
// ❌ 值拷贝
13
func BenchmarkRangeValue(b *testing.B) {
14
    for b.Loop() {
15
        for _, v := range bigSlice {
16
            _ = v.id
17
        }
18
    }
19
}
20

21
// ✅ 只用索引
22
func BenchmarkRangeIndex(b *testing.B) {
23
    for b.Loop() {
24
        for i := range bigSlice {
25
            _ = bigSlice[i].id
26
        }
27
    }
28
}

6. 正确写法总结#

速查表#

需求	推荐写法	避免写法
只读遍历	`for _, v := range s`	—
修改元素值	`for i := range s { s[i].Field = x }`	`for _, v := range s { v.Field = x }`
取元素地址	`for i := range s { p = &s[i] }`	`for _, v := range s { p = &v }`
Goroutine 闭包	`for _, v := range s { v := v; go fn(v) }`	`for _, v := range s { go fn(v) }`
大结构体遍历	`for i := range s { fn(s[i]) }`	`for _, v := range s { fn(v) }`
指针切片	`for _, v := range s { v.Field = x }` ✅	（指针切片直接用 value 即可）

决策流程#

1
                    使用 for...range 遍历切片/数组
2
                              │
3
                    ┌─────────┴─────────┐
4
                    │ 需要修改元素值？    │
5
                    └─────────┬─────────┘
6
                    Yes │          │ No
7
              ┌─────────┘          └─────────┐
8
              │ 用 for i := range           │ 用 for _, v := range
9
              │ s[i] 直接修改               │ 只读，代码简洁
10
              └─────────────────────────────┘
11
                              │
12
                    ┌─────────┴─────────┐
13
                    │ v 要用在闭包里？    │
14
                    └─────────┬─────────┘
15
                    Yes │          │ No
16
              ┌─────────┘          └──────┐
17
              │ v := v 创建局部副本        │ 直接使用
18
              └───────────────────────────┘

7. Go 1.22 变化：循环变量语义变更#

Go 1.22（2024年2月发布）改变了 for 循环变量的语义：每次迭代都会创建新的变量，而非复用同一个变量。

变更对比#

1
// Go 1.21 及之前：v 是同一个变量
2
for _, v := range nums {
3
    go func() {
4
        fmt.Print(v)  // 所有 goroutine 都打印最后一个值
5
    }()
6
}
7
// 输出（不确定顺序）: 50 50 50 50 50
8

9
// Go 1.22+：每次迭代创建新 v
10
for _, v := range nums {
11
    go func() {
12
        fmt.Print(v)  // 每个 goroutine 捕获各自的 v
13
    }()
14
}
15
// 输出（不确定顺序）: 10 20 30 40 50

哪些变，哪些没变#

行为	Go 1.21	Go 1.22
每次迭代的 `v` 是新变量	❌	✅
`&v` 在每次迭代中不同	❌	✅
`v` 仍是元素值的副本	✅	✅
修改 `v` 不影响原切片	✅	✅
`for i := range s` 不拷贝值	✅	✅

⚠️ 仍需注意的点#

即使 Go 1.22 修复了闭包问题，以下陷阱依然存在：

1
// ❌ 即使在 Go 1.22，修改 v 依然不影响原数据
2
for _, v := range users {
3
    v.Age += 1  // v 是副本，原数据不变（和 Go 1.21 一样）
4
}
5

6
// ❌ 即使在 Go 1.22，大结构体依然每次拷贝
7
for _, v := range bigStructSlice {
8
    process(v)  // 很重的值拷贝
9
}

总结#

for...range 的 value 永远是元素值的拷贝——这是 Go 语言保证的安全语义。记住三条核心原则：

改值用索引：for i := range s { s[i] = ... }

取址用索引：for i := range s { p = &s[i] }

大结构体用索引：for i := range s { fn(s[i]) }

HikariTish

目录#

1. 核心机制：值拷贝#

1.1 语法回顾#

1.2 底层发生了什么#

2. 陷阱一：修改 value 不会影响原数据#

问题代码#

正确写法#

3. 陷阱二：value 的地址始终不变#

问题代码#

原理图解#

正确写法#

4. 陷阱三：遍历的是原切片的副本#

4.1 `for...range` 的求值时机#

4.2 何时需要关注#

5. 陷阱四：大结构体的拷贝开销#

问题场景#

正确写法#

Benchmark 验证#

6. 正确写法总结#

速查表#

决策流程#

7. Go 1.22 变化：循环变量语义变更#

变更对比#

哪些变，哪些没变#

⚠️ 仍需注意的点#

总结#

相关链接#

继续阅读

换条路线

HikariTish

目录#

1. 核心机制：值拷贝#

1.1 语法回顾#

1.2 底层发生了什么#

2. 陷阱一：修改 value 不会影响原数据#

问题代码#

正确写法#

3. 陷阱二：value 的地址始终不变#

问题代码#

原理图解#

正确写法#

4. 陷阱三：遍历的是原切片的副本#

4.1 for...range 的求值时机#

4.2 何时需要关注#

5. 陷阱四：大结构体的拷贝开销#

问题场景#

正确写法#

Benchmark 验证#

6. 正确写法总结#

速查表#

决策流程#

7. Go 1.22 变化：循环变量语义变更#

变更对比#

哪些变，哪些没变#

⚠️ 仍需注意的点#

总结#

相关链接#

分享文章

沿着主题读

换条路线

4.1 `for...range` 的求值时机#