Go 循环之for循环，仅此一种
Go 循环之for循环，仅此一种
一、for 循环介绍
日常编码过程中，我们常常需要重复执行同一段代码，这时我们就需要循环结构来帮助我们控制程序的执行顺序。一个循环结构会执行循环体中的代码直到结尾，然后回到开头继续执行。 主流编程语言都提供了对循环结构的支持，绝大多数主流语言，比如：Python 提供了不止一种的循环语句，但 Go 却只有一种，也就是 for 语句。
二、for 循环结构
2.1 基本语法结构
Go语言的for循环的一般结构如下：
for 初始语句;条件表达式;结束语句{
循环体语句
}
- 初始语句：在循环开始前执行一次的初始化操作，通常用于声明计数器或迭代变量的初始值。
- 条件表达式：循环会在每次迭代之前检查条件表达式，只有当条件为真时，循循环才会继续执行。如果条件为假，循环结束。
- 结束语句：在每次迭代之后执行的操作，通常用于更新计数器或迭代变量的值。
以下是一个示例，演示了不同类型的for循环基本用法：
var sum int
for i := 0; i < 10; i++ {
sum += i
}
println(sum)
这种 for 语句的使用形式是 Go 语言中 for 循环语句的进形式。我们用一幅流程图来直观解释一下上面这句 for 循环语句的组成部分，以及各个部分的执行顺序：
从图中我们看到，经典 for 循环语句有四个组成部分（分别对应图中的①~④）。我们按顺序拆解一下这张图。
图中①对应的组成部分执行于循环体（③ ）之前，并且在整个 for 循环语句中仅会被执行一次，它也被称为循环前置语句。我们通常会在这个部分声明一些循环体（③ ）或循环控制条件（② ）会用到的自用变量，也称循环变量或迭代变量，比如这里声明的整型变量 i。与 if 语句中的自用变量一样，for 循环变量也采用短变量声明的形式，循环变量的作用域仅限于 for 语句隐式代码块范围内。
图中②对应的组成部分，是用来决定循环是否要继续进行下去的条件判断表达式。和 if 语句的一样，这个用于条件判断的表达式必须为布尔表达式，如果有多个判断条件，我们一样可以由逻辑操作符进行连接。当表达式的求值结果为 true 时，代码将进入循环体（③）继续执行，相反则循环直接结束，循环体（③）与组成部分④都不会被执行。
前面也多次提到了，图中③对应的组成部分是 for 循环语句的循环体。如果相关的判断条件表达式求值结构为 true 时，循环体就会被执行一次，这样的一次执行也被称为一次迭代（Iteration）。在上面例子中，循环体执行的动作是将这次迭代中变量 i 的值累加到变量 sum 中。
图中④对应的组成部分会在每次循环体迭代之后执行，也被称为循环后置语句。这个部分通常用于更新 for 循环语句组成部分①中声明的循环变量，比如在这个例子中，我们在这个组成部分对循环变量 i 进行加 1 操作。
2.2 省略初始值
for 循环的初始语句可以被忽略，但是必须要写初始语句后面的分号
i := 0
for ; i < 10; i++ {
fmt.Println(i)
}
2.3 省略初始语句和结束语句
for循环的初始语句和结束语句都可以省略,例如：
func main() {
var i int
for i < 10 {
fmt.Println(i)
i++
}
}
这种写法类似于其他编程语言中的while，在while后添加一个条件表达式，满足条件表达式时持续循环，否则结束循环。
2.4 无限循环
无限循环是一种循环结构，它会一直执行，而不受循环条件的限制,同时省略了初始语句，条件表达式，结束语句。基本语法格式如下:
for {
循环体语句
}
它的形式等价于：
for true {
// 循环体代码
}
或者等价于:
for ; ; {
// 循环体代码
}
在日常使用时，建议你用它的最简形式，也就是for {...}，更加简单。
举个栗子：
for {
fmt.Println("这是一个死循环!")
}
无限循环通常在编程中用于执行需要持续运行的任务，如服务器监听、事件处理等。
2.5 for 循环支持声明多循环变量
Go 语言的 for 循环支持声明多循环变量，并且可以应用在循环体以及判断条件中，比如下面就是一个使用多循环变量的、稍复杂的例子：
var sum int
for i, j, k := 0, 1, 2; (i < 20) && (j < 10) && (k < 30); i, j, k = i+1, j+1, k+5 {
sum += (i + j + k)
println(sum)
}
在这个例子中，我们声明了三个循环自用变量 i、j 和 k，它们共同参与了循环条件判断与循环体的执行。这段代码的执行流程解释如下：
- 开始时，
i被初始化为 0，j被初始化为 1，k被初始化为 2，sum被初始化为 0。 - 进入循环。在每次迭代中，首先检查三个条件：
i < 20、j < 10和k < 30。只有在这三个条件都为真时，循环才会继续执行。 - 在每次迭代中，计算
i + j + k的和，并将结果添加到sum中。 - 使用
println函数打印sum的当前值。 - 继续迭代，
i、j和k分别增加 1、1 和 5。 - 重复步骤 2、3、4 直到其中一个条件不再满足。在这种情况下，当
i大于或等于 20、j大于或等于 10 或k大于或等于 30 时，循环结束。
2.6 小练习：打印九九乘法表
for y := 1; y <= 9; y++ {
// 遍历, 决定这一行有多少列
for x := 1; x <= y; x++ {
fmt.Printf("%d*%d=%d ", x, y, x*y)
}
// 手动生成回车
fmt.Println()
}
输出结果如下：
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
执行过程如下：
for y := 1; y <= 9; y++：这是外部的for循环，它初始化一个名为y的循环变量，从1开始，每次迭代递增1，一直到y的值小于或等于9。- 内部的
for循环for x := 1; x <= y; x++：这是内部的for循环，用于控制每行的列数。循环变量x从1开始，每次迭代递增1，一直到x的值小于或等于y。这确保了每一行都只打印与行数相等或更小的列数。 fmt.Printf("%d*%d=%d ", x, y, x*y)：在内部循环中，这一行代码用于打印每个乘法表达式。它使用fmt.Printf函数，打印了一个格式化的字符串，其中%d是占位符，分别用x、y和x*y的值替换。这将打印类似 "11=1 "、"12=2 "、"2*2=4 " 的格式。fmt.Println()：在内部循环结束后，使用fmt.Println打印一个换行符，以将每行的输出分开。
三、for range(键值循环)
3.1 基本介绍
在编程中，经常需要遍历和操作集合（如数组、切片、映射等）中的元素。Go语言中可以使用for range遍历数组、切片、字符串、map 及通道（channel）。 通过for range遍历的返回值有以下规律：
- 数组、切片、字符串返回索引和值。
- map返回键和值。
- 通道（channel）只返回通道内的值。
3.2 基本语法格式
for range 循环的基本语法格式如下：
for key, value := range collection {
// 循环体代码，使用 key 和 value
}
key是元素的索引或键。value是元素的值。collection是要遍历的元素，如字符串、数组、切片、映射等。
举个例子,首先我们使用for 循环基本形式:
var sl = []int{1, 2, 3, 4, 5}
for i := 0; i < len(sl); i++ {
fmt.Printf("sl[%d] = %d\n", i, sl[i])
}
上面的例子中，我们使用循环前置语句中声明的循环变量 i 作为切片下标，逐一将切片中的元素读取了出来。不过，这样就有点麻烦了。但是使用for range 循环后如下:
var sl = []int{1, 2, 3, 4, 5}
for i, v := range sl {
fmt.Printf("sl[%d] = %d\n", i, v)
}
我们看到，for range 循环形式除了循环体保留了下来，其余组成部分都“不见”了。其实那几部分已经被融合到 for range 的语义中了。
具体来说，这里的 i 和 v 对应的是for 语句形式中循环前置语句的循环变量，它们的初值分别为切片 sl 的第一个元素的下标值和元素值。并且，隐含在 for range 语义中的循环控制条件判断为：是否已经遍历完 sl 的所有元素，等价于i < len(sl)这个布尔表达式。另外，每次迭代后，for range 会取出切片 sl 的下一个元素的下标和值，分别赋值给循环变量 i 和 v，这与 for 经典形式下的循环后置语句执行的逻辑是相同的。
3.3 for range 语句几个常见的“变种”
3.3.1 省略value
有时候，您可能只对元素中的index感兴趣，而不需要值value。在这种情况下，您可以省略值部分，只使用键。示例如下：
fruits := []string{"apple", "banana", "cherry"}
for index := range fruits {
fmt.Printf("Index: %d\n", index)
}
3.3.2 省略 key
如果我们不关心元素下标，只关心元素值，那么我们可以用空标识符替代代表下标值的变量 i。这里一定要注意，这个空标识符不能省略，否则就与上面形式一样了，Go 编译器将无法区分：
for _, v := range sl {
// ...
}
3.3.3 同时省略 key 和 value
如果我们既不关心元素下标值，也不关心元素值，那是否能写成下面这样呢：
for _, _ = range sl {
// ...
}
这种形式在语法上没有错误，就是看起来不太优雅。Go 在Go 1.4 版本中就提供了一种优雅的等价形式，后续直接使用这种形式就好了：
for range sl {
// ...
}
四、for 循环常用操作
4.1 遍历数组、切片——获得索引和元素
在遍历代码中，key 和 value 分别代表切片的下标及下标对应的值。下面的代码展示如何遍历切片，数组也是类似的遍历方法：
package main
import "fmt"
func main() {
for key, value := range []int{1, 2, 3, 4} {
fmt.Printf("key:%d value:%d\n", key, value)
}
}
/*
代码输出如下：
key:0 value:1
key:1 value:2
key:2 value:3
key:3 value:4
*/
4.2 遍历string 类型--获得字符串
下面这段代码展示了如何遍历字符串：
var s = "中国人"
for i, v := range s {
fmt.Printf("%d %s 0x%x\n", i, string(v), v)
}
输出结果如下：
0 中 0x4e2d
3 国 0x56fd
6 人 0x4eba
我们看到：for range 对于 string 类型来说，每次循环得到的 v 值是一个 Unicode 字符码点，也就是 rune 类型值，而不是一个字节，返回的第一个值 i 为该 Unicode 字符码点的内存编码（UTF-8）的第一个字节在字符串内存序列中的位置。
遍历map——获得map的键和值
map 就是一个键值对（key-value）集合，最常见的对 map 的操作，就是通过 key 获取其对应的 value 值。但有些时候，我们也要对 map 这个集合进行遍历，这就需要 for 语句的支持了。
但在 Go 语言中，我们要对 map 进行循环操作，for range 是唯一的方法，for 经典循环形式是不支持对 map 类型变量的循环控制的。下面是通过 for range，对一个 map 类型变量进行循环操作的示例：
var m = map[string]int {
"Rob" : 67,
"Russ" : 39,
"John" : 29,
}
for k, v := range m {
println(k, v)
}
运行这个示例，我们会看到这样的输出结果：
John 29
Rob 67
Russ 39
通过输出结果我们看到：for range 对于 map 类型来说，每次循环，循环变量 k 和 v 分别会被赋值为 map 键值对集合中一个元素的 key 值和 value 值。而且，map 类型中没有下标的概念，通过 key 和 value 来循环操作 map 类型变量也就十分自然了。
遍历通道（channel）——接收通道数据
除了可以针对 string、数组 / 切片，以及 map 类型变量进行循环操作控制之外，for range 还可以与 channel 类型配合工作。
c := make(chan int)
go func() {
c <- 1
c <- 2
c <- 3
close(c)
}()
for v := range c {
fmt.Println(v)
}
channel 是 Go 语言提供的并发设计的原语，它用于多个 Goroutine 之间的通信。当 channel 类型变量作为 for range 语句的迭代对象时，for range 会尝试从 channel 中读取数据，使用形式是这样的：
var c = make(chan int)
for v := range c {
// ...
}
在这个例子中，for range 每次从 channel 中读取一个元素后，会把它赋值给循环变量 v，并进入循环体。当 channel 中没有数据可读的时候， for range 循环会阻塞在对 channel 的读操作上。直到 channel 关闭时，for range 循环才会结束，这也是 for range 循环与 channel 配合时隐含的循环判断条件。
五、跳出循环与终止循环
5.1 continue 语句(继续下次循环)
5.1.1 continue 基本语法
首先，我们来看第一种场景。如果循环体中的代码执行到一半，要中断当前迭代，忽略此迭代循环体中的后续代码，并回到 for 循环条件判断，尝试开启下一次迭代，这个时候我们可以怎么办呢？我们可以使用 continue 语句来应对。基本语法如下：
for initialization; condition; update {
// 循环体
if someCondition {
continue
}
// 其他循环体的代码
}
initialization是初始化语句，通常用于初始化循环变量。condition是循环条件，当条件为真时继续循环，否则退出。update是在每次迭代后执行的操作，通常用于更新循环变量。
带标签的 continue 语句用于跳过当前迭代中 if 语句中的 someCondition 满足的部分，直接进行下一次迭代。如果没有标签，continue 将默认跳过当前循环的下一次迭代。
以下是一个示例，演示 continue 语句的基本语法：
var sum int
var sl = []int{1, 2, 3, 4, 5, 6}
for i := 0; i < len(sl); i++ {
if sl[i]%2 == 0 {
// 忽略切片中值为偶数的元素
continue
}
sum += sl[i]
}
println(sum) // 9
这段代码会循环遍历切片中的元素，把值为奇数的元素相加，然后存储在变量 sum 中。我们可以看到，在这个代码的循环体中，如果我们判断切片元素值为偶数，就使用 continue 语句中断当前循环体的执行，那么循环体下面的 sum += sl[i] 在这轮迭代中就会被忽略。代码执行流会直接来到循环后置语句i++，之后对循环条件表达式（i < len(sl)）进行求值，如果为 true，将再次进入循环体，开启新一次迭代。
5.1.2 带标签的continue语句
Go 语言中的 continue 在 C 语言 continue 语义的基础上又增加了对 label 的支持。label 语句的作用，是标记跳转的目标。带标签的continue语句的基本语法格式如下：
loopLabel:
for initialization; condition; update {
// 循环体
if someCondition {
continue loopLabel
}
}
loopLabel是一个用户定义的标签（标识符），用于标记循环。initialization是初始化语句，通常用于初始化循环变量。condition是循环条件，当条件为真时继续循环，否则退出。update是在每次迭代后执行的操作，通常用于更新循环变量。
带标签的continue语句用于在嵌套循环中指定要跳过的循环，其工作方式是：如果某个条件满足，执行continue loopLabel，其中loopLabel是要跳过的循环的标签，它将控制流转移到带有相应标签的循环的下一次迭代。如果没有指定标签，continue将默认跳过当前循环的下一次迭代。
我们可以把上面的代码改造为使用 label 的等价形式：
func main() {
var sum int
var sl = []int{1, 2, 3, 4, 5, 6}
loop:
for i := 0; i < len(sl); i++ {
if sl[i]%2 == 0 {
// 忽略切片中值为偶数的元素
continue loop
}
sum += sl[i]
}
println(sum) // 9
}
你可以看到，在这段代码中，我们定义了一个 label：loop，它标记的跳转目标恰恰就是我们的 for 循环。也就是说，我们在循环体中可以使用continue+ loop label的方式来实现循环体中断，这与前面的例子在语义上是等价的。不过这里仅仅是一个演示，通常我们在这样非嵌套循环的场景中会直接使用不带 label 的 continue 语句。
而带 label 的 continue 语句，通常出现于嵌套循环语句中，被用于跳转到外层循环并继续执行外层循环语句的下一个迭代，比如下面这段代码：
func main() {
var sl = [][]int{
{1, 34, 26, 35, 78},
{3, 45, 13, 24, 99},
{101, 13, 38, 7, 127},
{54, 27, 40, 83, 81},
}
outerloop:
for i := 0; i < len(sl); i++ {
for j := 0; j < len(sl[i]); j++ {
if sl[i][j] == 13 {
fmt.Printf("found 13 at [%d, %d]\n", i, j)
continue outerloop
}
}
}
}
在这段代码中，变量 sl 是一个元素类型为[]int 的切片（二维切片），其每个元素切片中至多包含一个整型数 13。main 函数的逻辑就是在 sl 的每个元素切片中找到 13 这个数字，并输出它的具体位置信息。
那这要怎么查找呢？一种好的实现方式就是，我们只需要在每个切片中找到 13，就不用继续在这个切片的剩余元素中查找了。
我们用 for 经典形式来实现这个逻辑。面对这个问题，我们要使用嵌套循环，具体来说就是外层循环遍历 sl 中的元素切片，内层循环遍历每个元素切片中的整型值。一旦内层循环发现 13 这个数值，我们便要中断内层 for 循环，回到外层 for 循环继续执行。
如果我们用不带 label 的 continue 能不能完成这一功能呢？答案是不能。因为它只能中断内层循环的循环体，并继续开启内层循环的下一次迭代。而带 label 的 continue 语句是这个场景下的“最佳人选”，它会直接结束内层循环的执行，并回到外层循环继续执行。
这一行为就好比在外层循环放置并执行了一个不带label的 continue 语句。它会中断外层循环中当前迭代的执行，执行外层循环的后置语句（i++），然后再对外层循环的循环控制条件语句进行求值，如果为 true，就将继续执行外层循环的新一次迭代。
5.2 goto(跳转到指定标签)
goto语句通过标签进行代码间的无条件跳转。goto语句可以在快速跳出循环、避免重复退出上有一定的帮助。Go语言中使用goto语句能简化一些代码的实现过程。 例如双层嵌套的for循环要退出时：
func main() {
var breakFlag bool
for i := 0; i < 10; i++ {
for j := 0; j < 10; j++ {
if j == 2 {
// 设置退出标签
breakFlag = true
break
}
fmt.Printf("%v-%v\n", i, j)
}
// 外层for循环判断
if breakFlag {
break
}
}
}
使用goto语句能简化代码：
func main() {
for i := 0; i < 10; i++ {
for j := 0; j < 10; j++ {
if j == 2 {
// 设置退出标签
goto breakTag
}
fmt.Printf("%v-%v\n", i, j)
}
}
return
// 标签
breakTag:
fmt.Println("结束for循环")
}
goto 是一种公认的、难于驾驭的语法元素，应用 goto 的代码可读性差、代码难于维护还易错。虽然 Go 语言保留了 goto，在平常开发中,不推荐使用。
5.3 break(跳出循环)
日常编码中，我们还会遇到一些场景，在这些场景中，我们不仅要中断当前循环体迭代的进行，还要同时彻底跳出循环，终结整个循环语句的执行。面对这样的场景，continue 语句就不再适用了，Go 语言为我们提供了 break 语句来解决这个问题。
5.3.1 break基本语法
break语句的基本语法如下：
for initialization; condition; update {
// 循环体
if someCondition {
break
}
// 其他循环体的代码
}
initialization是初始化语句，通常用于初始化循环变量。condition是循环条件，当条件为真时继续循环，否则退出。update是在每次迭代后执行的操作，通常用于更新循环变量。
当在循环中执行 break 语句时，它会立即终止当前的循环，无论条件是否满足，然后将控制流传递到循环之后的代码。
我们来看下面这个示例中 break 语句的应用：
func main() {
var sl = []int{5, 19, 6, 3, 8, 12}
var firstEven int = -1
// 找出整型切片sl中的第一个偶数
for i := 0; i < len(sl); i++ {
if sl[i]%2 == 0 {
firstEven = sl[i]
break
}
}
println(firstEven) // 6
}
这段代码逻辑很容易理解，我们通过一个循环结构来找出切片 sl 中的第一个偶数，一旦找到就不需要继续执行后续迭代了。这个时候我们就通过 break 语句跳出了这个循环。
5.3.2 带标签的break语法
和 continue 语句一样，Go 也 break 语句增加了对 label 的支持。而且，和前面 continue 语句一样，如果遇到嵌套循环，break 要想跳出外层循环，用不带 label 的 break 是不够，因为不带 label 的 break 仅能跳出其所在的最内层循环。要想实现外层循环的跳出，我们还需给 break 加上 label。所以，带标签的 break 语句允许您从嵌套循环中跳出特定循环，而不是默认跳出当前循环。带标签的 break 语法如下：
loopLabel:
for initialization; condition; update {
// 循环体
if someCondition {
break loopLabel
}
// 其他循环体的代码
}
loopLabel是用户定义的标签（标识符），用于标记循环。initialization是初始化语句，通常用于初始化循环变量。condition是循环条件，当条件为真时继续循环，否则退出。update是在每次迭代后执行的操作，通常用于更新循环变量。
当带标签的 break 语句执行时，它会终止带有相应标签的循环，而不是默认的当前循环。
我们来看一个具体的例子：
var gold = 38
func main() {
var sl = [][]int{
{1, 34, 26, 35, 78},
{3, 45, 13, 24, 99},
{101, 13, 38, 7, 127},
{54, 27, 40, 83, 81},
}
outerloop:
for i := 0; i < len(sl); i++ {
for j := 0; j < len(sl[i]); j++ {
if sl[i][j] == gold {
fmt.Printf("found gold at [%d, %d]\n", i, j)
break outerloop
}
}
}
}
这个例子和我们前面的带 label 的 continue 语句的例子很像，main 函数的逻辑就是，在 sl 这个二维切片中找到 38 这个数字，并输出它的位置信息。整个二维切片中至多有一个值为 38 的元素，所以只要我们通过嵌套循环发现了 38，我们就不需要继续执行这个循环了。这时，我们通过带有 label 的 break 语句，就可以直接终结外层循环，从而从复杂多层次的嵌套循环中直接跳出，避免不必要的算力资源的浪费。
六、for 循环常见“坑”与避坑指南
for 语句的常见“坑”点通常和 for range 这个“语法糖”有关。虽然 for range 的引入提升了 Go 语言的表达能力，也简化了循环结构的编写，但 for range 也不是“免费的午餐”，在开发中，经常会遇到一些问题，下面我们就来看看这些常见的问题。
6.1 循环变量的重用
我们前面说过，for range 形式的循环语句，使用短变量声明的方式来声明循环变量，循环体将使用这些循环变量实现特定的逻辑，但你在刚开始学习使用的时候，可能会发现循环变量的值与你之前的“预期”不符，比如下面这个例子：
func main() {
var m = []int{1, 2, 3, 4, 5}
for i, v := range m {
go func() {
time.Sleep(time.Second * 3)
fmt.Println(i, v)
}()
}
time.Sleep(time.Second * 10)
}
这个示例是对一个整型切片进行遍历，并且在每次循环体的迭代中都会创建一个新的 Goroutine（Go 中的轻量级协程），输出这次迭代的元素的下标值与元素值。
现在我们继续看这个例子，我们预期的输出结果可能是这样的：
0 1
1 2
2 3
3 4
4 5
那实际输出真的是这样吗？我们实际运行输出一下：
4 5
4 5
4 5
4 5
4 5
我们看到，Goroutine 中输出的循环变量，也就是 i 和 v 的值都是 for range 循环结束后的最终值，而不是各个 Goroutine 启动时变量 i 和 v 的值，与我们最初的“预期”不符，这是为什么呢？
这是因为我们最初的“预期”本身就是错的。这里，很可能会被 for range 语句中的短声明变量形式“迷惑”，简单地认为每次迭代都会重新声明两个新的变量 i 和 v。但事实上，这些循环变量在 for range 语句中仅会被声明一次，且在每次迭代中都会被重用。
基于隐式代码块的规则，我们可以将上面的 for range 语句做一个等价转换，这样可以帮助你理解 for range 的工作原理。等价转换后的结果是这样的：
func main() {
var m = []int{1, 2, 3, 4, 5}
{
i, v := 0, 0
for i, v = range m {
go func() {
time.Sleep(time.Second * 3)
fmt.Println(i, v)
}()
}
}
time.Sleep(time.Second * 10)
}
通过等价转换后的代码，我们可以清晰地看到循环变量 i 和 v 在每次迭代时的重用。而 Goroutine 执行的闭包函数引用了它的外层包裹函数中的变量 i、v，这样，变量 i、v 在主 Goroutine 和新启动的 Goroutine 之间实现了共享，而 i, v 值在整个循环过程中是重用的，仅有一份。在 for range 循环结束后，i = 4, v = 5，因此各个 Goroutine 在等待 3 秒后进行输出的时候，输出的是 i, v 的最终值。
那么如何修改代码，可以让实际输出和我们最初的预期输出一致呢？我们可以为闭包函数增加参数，并且在创建 Goroutine 时将参数与 i、v 的当时值进行绑定，看下面的修正代码：
func main() {
var m = []int{1, 2, 3, 4, 5}
for i, v := range m {
go func(i, v int) {
time.Sleep(time.Second * 3)
fmt.Println(i, v)
}(i, v)
}
time.Sleep(time.Second * 10)
}
这回的输出结果与我们的预期就是一致的了。不过这里你要注意：你执行这个程序的输出结果的行序，可能与我的不同，这是由 Goroutine 的调度所决定的。
6.2 参与循环的是 range 表达式的副本
在 for range 语句中，range 后面接受的表达式的类型可以是数组、指向数组的指针、切片、字符串，还有 map 和 channel（需具有读权限）。我们以数组为例来看一个简单的例子：
func main() {
var a = [5]int{1, 2, 3, 4, 5}
var r [5]int
fmt.Println("original a =", a)
for i, v := range a {
if i == 0 {
a[1] = 12
a[2] = 13
}
r[i] = v
}
fmt.Println("after for range loop, r =", r)
fmt.Println("after for range loop, a =", a)
}
这个例子说的是对一个数组 a 的元素进行遍历操作，当处理下标为 0 的元素时，我们修改了数组 a 的第二个和第三个元素的值，并且在每个迭代中，我们都将从 a 中取得的元素值赋值给新数组 r。我们期望这个程序会输出如下结果：
original a = [1 2 3 4 5]
after for range loop, r = [1 12 13 4 5]
after for range loop, a = [1 12 13 4 5]
但实际运行该程序的输出结果却是：
original a = [1 2 3 4 5]
after for range loop, r = [1 2 3 4 5]
after for range loop, a = [1 12 13 4 5]
我们原以为在第一次迭代过程，也就是 i = 0 时，我们对 a 的修改 (a[1] =12,a[2] = 13) 会在第二次、第三次迭代中被 v 取出，但从结果来看，v 取出的依旧是 a 被修改前的值：2 和 3。
为什么会是这种情况呢？原因就是参与 for range 循环的是 range 表达式的副本。也就是说，在上面这个例子中，真正参与循环的是 a 的副本，而不是真正的 a。
为了方便你理解，我们将上面的例子中的 for range 循环，用一个等价的伪代码形式重写一下：
for i, v := range a' { //a'是a的一个值拷贝
if i == 0 {
a[1] = 12
a[2] = 13
}
r[i] = v
}
现在真相终于揭开了：这个例子中，每次迭代的都是从数组 a 的值拷贝 a’中得到的元素。a’是 Go 临时分配的连续字节序列，与 a 完全不是一块内存区域。因此无论 a 被如何修改，它参与循环的副本 a’依旧保持原值，因此 v 从 a’中取出的仍旧是 a 的原值，而不是修改后的值。
那么应该如何解决这个问题，让输出结果符合我们前面的预期呢？在 Go 中，大多数应用数组的场景我们都可以用切片替代，这里我们也用切片来试试看：
func main() {
var a = [5]int{1, 2, 3, 4, 5}
var r [5]int
fmt.Println("original a =", a)
for i, v := range a[:] {
if i == 0 {
a[1] = 12
a[2] = 13
}
r[i] = v
}
fmt.Println("after for range loop, r =", r)
fmt.Println("after for range loop, a =", a)
}
你可以看到，在 range 表达式中，我们用了 a[:]替代了原先的 a，也就是将数组 a 转换为一个切片，作为 range 表达式的循环对象。运行这个修改后的例子，结果是这样的：
original a = [1 2 3 4 5]
after for range loop, r = [1 12 13 4 5]
after for range loop, a = [1 12 13 4 5]
我们看到输出的结果与最初的预期终于一致了，显然用切片能实现我们的要求。
那切片是如何做到的呢？切片在 Go 内部表示为一个结构体，由（array, len, cap）组成，其中 array 是指向切片对应的底层数组的指针，len 是切片当前长度，cap 为切片的最大容量。
所以，当进行 range 表达式复制时，我们实际上复制的是一个切片，也就是表示切片的结构体。表示切片副本的结构体中的 array，依旧指向原切片对应的底层数组，所以我们对切片副本的修改也都会反映到底层数组 a 上去。而 v 再从切片副本结构体中 array 指向的底层数组中，获取数组元素，也就得到了被修改后的元素值。
6.3 遍历 map 中元素的随机性
根据上面的讲解，当 map 类型变量作为 range 表达式时，我们得到的 map 变量的副本与原变量指向同一个 map。如果我们在循环的过程中，对 map 进行了修改，那么这样修改的结果是否会影响后续迭代呢？这个结果和我们遍历 map 一样，具有随机性。
比如我们来看下面这个例子，在 map 循环过程中，当 counter 值为 0 时，我们删除了变量 m 中的一个元素：
var m = map[string]int{
"tony": 21,
"tom": 22,
"jim": 23,
}
counter := 0
for k, v := range m {
if counter == 0 {
delete(m, "tony")
}
counter++
fmt.Println(k, v)
}
fmt.Println("counter is ", counter)
如果我们反复运行这个例子多次，会得到两个不同的结果。当 k="tony"作为第一个迭代的元素时，我们将得到如下结果：
tony 21
tom 22
jim 23
counter is 3
否则，我们得到的结果是这样的：
tom 22
jim 23
counter is 2
如果我们在针对 map 类型的循环体中，新创建了一个 map 元素项，那这项元素可能出现在后续循环中，也可能不出现：
var m = map[string]int{
"tony": 21,
"tom": 22,
"jim": 23,
}
counter := 0
for k, v := range m {
if counter == 0 {
m["lucy"] = 24
}
counter++
fmt.Println(k, v)
}
fmt.Println("counter is ", counter)
这个例子的执行结果也会有两个:
tony 21
tom 22
jim 23
lucy 24
counter is 4
或：
tony 21
tom 22
jim 23
counter is 3
考虑到上述这种随机性，我们日常编码遇到遍历 map 的同时，还需要对 map 进行修改的场景的时候，要格外小心。
本文作者：贾维斯Echo
本文链接：https://www.cnblogs.com/taoxiaoxin/p/17758608.html
版权声明：本作品采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
2020-10-12 操作系统与计算机网络