Go 语言循环语句
在不少实际问题中有许多具有规律性的重复操作，因此在程序中就需要重复执行某些语句。
以下为大多编程语言循环程序的流程图：
image.png
Go 语言提供了以下几种类型循环处理语句：
| 循环类型 | 描述 |
|---|---|
| for 循环 | 重复执行语句块 |
| 循环嵌套 | 在 for 循环中嵌套一个或多个 for 循环 |
循环控制语句
循环控制语句可以控制循环体内语句的执行过程。
GO 语言支持以下几种循环控制语句：
| 控制语句 | 描述 |
|---|---|
| break 语句 | 经常用于中断当前 for 循环或跳出 switch 语句 |
| continue 语句 | 跳过当前循环的剩余语句，然后继续进行下一轮循环。 |
| goto 语句 | 将控制转移到被标记的语句。 |
无限循环
如果循环中条件语句永远不为 false 则会进行无限循环，我们可以通过 for 循环语句中只设置一个条件表达式来执行无限循环：
package main
import "fmt"
func main() {
for true {
fmt.Printf("这是无限循环。\n");
}
}
Go 语言 for 循环
for循环是一个循环控制结构，可以执行指定次数的循环。
语法
Go语言的For循环有3中形式，只有其中的一种使用分号。
和 C 语言的 for 一样：
for init; condition; post { }
和 C 的 while 一样：
for condition { }
和 C 的 for(;;) 一样：
for { }
- init： 一般为赋值表达式，给控制变量赋初值；
- condition： 关系表达式或逻辑表达式，循环控制条件；
- post： 一般为赋值表达式，给控制变量增量或减量。
for语句执行过程如下：
- ①先对表达式1赋初值；
- ②判别赋值表达式 init 是否满足给定条件，若其值为真，满足循环条件，则执行循环体内语句，然后执行 post，进入第二次循环，再判别 condition；否则判断 condition 的值为假，不满足条件，就终止for循环，执行循环体外语句。
for 循环的 range格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下：
for key, value := range oldMap {
newMap[key] = value
}
for语句语法流程如下图所示：
image.png
实例
package main
import "fmt"
func main() {
var b int = 15
var a int
numbers := [6]int{1, 2, 3, 5} //数组,没有进行赋值的地方就是0
/* for 循环 */
for a := 0; a < 10; a++ { //这里的a进行了重新定义,只在当前的循环块起作用
fmt.Printf("a 的值为: %d\n", a)
}
for a < b { //a的默认值是0别忘了
a++
fmt.Printf("a 的值为: %d\n", a)
}
for i,x:= range numbers { //类似于这个python的enumerate
fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
}
}
以上实例运行输出结果为:
a 的值为: 0
a 的值为: 1
a 的值为: 2
a 的值为: 3
a 的值为: 4
a 的值为: 5
a 的值为: 6
a 的值为: 7
a 的值为: 8
a 的值为: 9
a 的值为: 1
a 的值为: 2
a 的值为: 3
a 的值为: 4
a 的值为: 5
a 的值为: 6
a 的值为: 7
a 的值为: 8
a 的值为: 9
a 的值为: 10
a 的值为: 11
a 的值为: 12
a 的值为: 13
a 的值为: 14
a 的值为: 15
第 0 位 x 的值 = 1
第 1 位 x 的值 = 2
第 2 位 x 的值 = 3
第 3 位 x 的值 = 5
第 4 位 x 的值 = 0
第 5 位 x 的值 = 0
Go 语言循环嵌套
Go 语言允许用户在循环内使用循环。接下来我们将为大家介绍嵌套循环的使用。
语法
以下为 Go 语言嵌套循环的格式：
for [condition | ( init; condition; increment ) | Range] // |是或者的意思
{
for [condition | ( init; condition; increment ) | Range]
{
statement(s); //statement执行语句
}
statement(s);
}
实例
以下实例使用循环嵌套来输出 2 到 100 间的素数：
package main
import "fmt"
func main() {
/* 定义局部变量 */
var i, j int
for i=2; i < 100; i++ { //中间用;分开其实是表示三句话
for j=2; j <= (i/j); j++ {
if(i%j==0) {
break; // 如果发现因子，则不是素数
}
}
if(j > (i/j)) {
fmt.Printf("%d 是素数\n", i);
}
}
}
以上实例运行输出结果为:
2 是素数
3 是素数
5 是素数
7 是素数
11 是素数
13 是素数
17 是素数
19 是素数
23 是素数
29 是素数
31 是素数
37 是素数
41 是素数
43 是素数
47 是素数
53 是素数
59 是素数
61 是素数
67 是素数
71 是素数
73 是素数
79 是素数
83 是素数
89 是素数
97 是素数
笔记
九九乘法表：
package main
import "fmt"
func main() {
for m := 1; m < 10; m++ {
/* fmt.Printf("第%d次：\n",m) */
for n := 1; n <= m; n++ {
fmt.Printf("%dx%d=%d ",n,m,m*n)
}
fmt.Println("")
}
}
Go 语言 break 语句
Go 语言中 break 语句用于以下两方面：
- 用于循环语句中跳出循环，并开始执行循环之后的语句。
- break 在 switch（开关语句）中在执行一条case后跳出语句的作用。
语法
break 语法格式如下：
break;
image.png
实例
在变量 a 大于 15 的时候跳出循环：
package main
import "fmt"
func main() {
/* 定义局部变量 */
var a int = 10
/* for 循环 */
for a < 20 {
fmt.Printf("a 的值为 : %d\n", a);
a++;
if a > 15 {
/* 使用 break 语句跳出循环 */
break;
}
}
}
以上实例执行结果为：
a 的值为 : 10
a 的值为 : 11
a 的值为 : 12
a 的值为 : 13
a 的值为 : 14
a 的值为 : 15
Go 语言 continue 语句
Go 语言的 continue 语句 有点像 break 语句。但是 continue 不是跳出循环，而是跳过当前循环执行下一次循环语句。
for 循环中，执行 continue 语句会触发for增量语句的执行。
语法
continue 语法格式如下：
continue;
continue 语句流程图如下：
image.png
实例
在变量 a 等于 15 的时候跳过本次循环执行下一次循环：
package main
import "fmt"
func main() {
/* 定义局部变量 */
var a int = 10
/* for 循环 */
for a < 20 {
if a == 15 {
/* 跳过此次循环 */
a = a + 1;
continue;
}
fmt.Printf("a 的值为 : %d\n", a);
a++;
}
}
以上实例执行结果为：
a 的值为 : 10
a 的值为 : 11
a 的值为 : 12
a 的值为 : 13
a 的值为 : 14
a 的值为 : 16
a 的值为 : 17
a 的值为 : 18
a 的值为 : 19
注意
注意：break可⽤于for、switch、select，⽽continue仅能⽤于for循环。
Go 语言 goto 语句
Go 语言的 goto 语句可以无条件地转移到过程中指定的行。
goto 语句通常与条件语句配合使用。可用来实现条件转移， 构成循环，跳出循环体等功能。
但是，在结构化程序设计中一般不主张使用 goto 语句， 以免造成程序流程的混乱，使理解和调试程序都产生困难。
注意
用goto跳转到必须在当前函数内定义的标签
语法
goto 语法格式如下：
goto label;
..
.
label: statement;
goto 语句流程图如下：
image.png
实例
在变量 a 等于 15 的时候跳过本次循环并回到循环的开始语句 LOOP 处：
package main
import "fmt"
func main() {
/* 定义局部变量 */
var a int = 10
/* 循环 */
LOOP: for a < 20 { //LOOP其实是定义了个名字
if a == 15 {
/* 跳过迭代 */
a = a + 1
goto LOOP
}
fmt.Printf("a的值为 : %d\n", a)
a++
}
}
以上实例执行结果为：
a的值为 : 10
a的值为 : 11
a的值为 : 12
a的值为 : 13
a的值为 : 14
a的值为 : 16
a的值为 : 17
a的值为 : 18
a的值为 : 19
实例
package main //必须有一个main包
import "fmt"
func main() {
//break //break is not in a loop, switch, or select
//continue//continue is not in a loop
//goto可以用在任何地方，但是不能夸函数使用
fmt.Println("11111111111111")
goto End //goto是关键字， End是用户起的名字， 他叫标签
fmt.Println("222222222222222")
End:
fmt.Println("3333333333333")
}
执行结果
11111111111111
3333333333333
笔记
打印九九乘法表:
package main
import "fmt"
func main() {
//print9x()
gotoTag()
}
//嵌套for循环打印九九乘法表
func print9x() {
for m := 1; m < 10; m++ {
for n := 1; n <= m; n++ {
fmt.Printf("%dx%d=%d ",n,m,m*n)
}
fmt.Println("")
}
}
//for循环配合goto打印九九乘法表
func gotoTag() {
for m := 1; m < 10; m++ {
n := 1
LOOP: if n <= m {
fmt.Printf("%dx%d=%d ",n,m,m*n)
n++
goto LOOP
} else {
fmt.Println("")
}
n++
}
}
range 语句(后面用的会很多)
关键字 range 会返回两个值，第一个返回值是元素的数组下标，第二个返回值是元素的值：
实例
package main //必须有一个main包
import "fmt"
func main() {
str := "abc"
//通过for打印每个字符
for i := 0; i < len(str); i++ {
fmt.Printf("str[%d]=%c\n", i, str[i])
}
//迭代打印每个元素，默认返回2个值: 一个是元素的位置，一个是元素本身
for i, data := range str {
fmt.Printf("str[%d]=%c\n", i, data)
}
for i := range str { //第2个返回值，默认丢弃，返回元素的位置(下标)
fmt.Printf("str[%d]=%c\n", i, str[i])
}
for i, _ := range str { //第2个返回值，默认丢弃，返回元素的位置(下标) //现在这个 _ 的作用就出现了
fmt.Printf("str[%d]=%c\n", i, str[i])
}
}
执行结果
str[0]=a
str[1]=b
str[2]=c
str[0]=a
str[1]=b
str[2]=c
str[0]=a
str[1]=b
str[2]=c
str[0]=a
str[1]=b
str[2]=c