作者简介：
高科，先后在 IBM PlatformComputing从事网格计算，淘米网，网易从事游戏服务器开发，拥有丰富的C++，go等语言开发经验，mysql，mongo，redis等数据库，设计模式和网络库开发经验，对战棋类，回合制，moba类页游，手游有丰富的架构设计和开发经验。 （谢谢你的关注）
--------------------------------------------------------------------------------------------------------------------------------
前言
Go 语言提供了 for 循环语句，用于重复执行一段程序逻辑，直到循环条件不再满足时终止。
循环可以用于迭代各种数据结构（例如切片、数组、映射或字符串）中的元素
本文将很基础的for循环语法，循环嵌套，无限循环，goto，break，continue呈现给正在学习go开发的读者。
for
语法
Go语言的for循环有3中形式，只有其中的一种使用分号。
for init; condition; post { }
for condition { }
for { }
init： 一般为赋值表达式，给控制变量赋初值；
condition： 关系表达式或逻辑表达式，循环控制条件；
post： 一般为赋值表达式，给控制变量增量或减量。
for语句执行过程如下：
①先对表达式 init 赋初值；
②判别赋值表达式 init 是否满足给定 condition 条件，若其值为真，满足循环条件，则执行循环体内语句，然后执行 post，进入第二次循环，再判别 condition；否则判断 condition 的值为假，不满足条件，就终止for循环，执行循环体外语句。
s := "abc"
for i, n := 0, len(s); i < n; i++ { // 常见的 for 循环，支持初始化语句。
println(s[i])
}
n := len(s)
for n > 0 { // 替代 while (n > 0) {}
n--
println(s[n]) // 替代 for (; n > 0;) {}
}
for { // 替代 while (true) {}
println(s) // 替代 for (;;) {}
} 不要期望编译器能理解你的想法，在初始化语句中计算出全部结果是个好主意。
package main
func length(s string) int {
println("call length.")
return len(s)
}
func main() {
s := "abcd"
for i, n := 0, length(s); i < n; i++ { // 避免多次调用 length 函数。
println(i, s[i])
}
} 输出:
call length.
0 97
1 98
2 99
3 100
for-range
range类似迭代器操作，返回 (索引, 值) 或 (键, 值)。
for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下：
for key, value := range oldMap {
newMap[key] = value
} | 1st value | 2nd value | ||
|---|---|---|---|
| string | index | s[index] | unicode, rune |
| array/slice | index | s[index] | |
| map | key | m[key] | |
| channel | element |
可忽略不想要的返回值，或 "_" 这个特殊变量。
1. 迭代字符串
该for-range循环可用于访问字符串中的各个字符。
package main
import "fmt"
func main() {
for i, ch := range "World" {
fmt.Printf("%#U starts at byte position %d\n", ch, i)
}
}以上实例运行输出结果为:
U+0057 'W' starts at byte position 0
U+006F 'o' starts at byte position 1
U+0072 'r' starts at byte position 2
U+006C 'l' starts at byte position 3
U+0064 'd' starts at byte position 42. 迭代map
该for-range循环可用于访问映射中的各个键值对。
package main
import "fmt"
func main() {
m := map[string]int{
"one": 1,
"two": 2,
"three": 3,
}
for key, value := range m {
fmt.Println(key, value)
}
}输出结果：
one 1
two 2
three 3 3. 迭代通道
对于通道，迭代值是在通道关闭之前在通道上发送的连续值。
package main
import "fmt"
func main() {
mychannel := make(chan int)
go func() {
mychannel <- 1
mychannel <- 2
mychannel <- 3
close(mychannel)
}()
for n := range mychannel {
fmt.Println(n)
}
}输出：
1
2
3循环嵌套
在 for 循环中嵌套一个或多个 for 循环
语法
以下为 Go 语言嵌套循环的格式：
for [condition | ( init; condition; increment ) | Range]
{
for [condition | ( init; condition; increment ) | Range]
{
statement(s)
}
statement(s)
} 实例：
下面这个例子使用了两个 for 循环来实现循环嵌套。外层的循环变量为 i，范围是 1 到 3，内层的循环变量为 j，范围也是 1 到 3。
package main
import "fmt"
func main() {
for i := 1; i <= 3; i++ {
for j := 1; j <= 3; j++ {
fmt.Printf("i: %d, j: %d\n", i, j)
}
}
}
最终的输出结果为：：
i: 1, j: 1
i: 1, j: 2
i: 1, j: 3
i: 2, j: 1
i: 2, j: 2
i: 2, j: 3
i: 3, j: 1
i: 3, j: 2
i: 3, j: 3
无限循环
如过循环中条件语句永远不为 false 则会进行无限循环，我们可以通过 for 循环语句中只设置一个条件表达式来执行无限循环：
package main
import "fmt"
func main() {
for true {
fmt.Printf("这是无限循环。\n");
}
} 细心的读者可能已经发现了实际上for true {} 和for {}是等价的，所以这两种方式都可以，只不过在阅读代码的时候你需要知道这种方式。
goto、break、continue
如果你有其他语言的开发基础，我i想你对这三个关键词很熟悉， 同样的在Go中，goto、break和continue也是三种控制流语句，用于改变程序的执行顺序
goto语句：
- 语法：goto label
- 作用：无条件跳转到指定的标签处执行，可以跳转到同一个函数或代码块内的任意位置。
- 注意事项：goto语句应该慎用，因为滥用goto会导致代码难以理解和维护。
示例代码：
func main() {
i := 0
Loop:
if i < 5 {
fmt.Println(i)
i++
goto Loop
}
}
break语句：
- 语法：break
- 作用：跳出循环体或switch语句，结束当前循环或switch语句的执行，继续执行循环或switch之后的代码。
- 注意事项：break语句只能用于循环体或switch语句的内部，不可用于其他地方。
示例代码：
func main() {
for i := 0; i < 10; i++ {
if i == 5 {
break
}
fmt.Println(i)
}
}
continue语句：
- 语法：continue
- 作用：终止当前迭代，跳过本次循环中continue语句之后的代码，开始下一次迭代。
- 注意事项：continue语句只能用于循环体内部，不可用于其他地方。
示例代码：
func main() {
for i := 0; i < 5; i++ {
if i == 2 {
continue
}
fmt.Println(i)
}
}
- goto语句用于无条件跳转到指定位置执行，慎用。
- break语句用于结束当前循环或switch语句的执行，继续执行之后的代码。
- continue语句用于跳过本次循环的剩余代码，开始下一次迭代。
