Go语言【第六篇】：Go循环语句

Go语言循环语句

在不少实际问题中有许多具有规律性的重复操作，因此在程序中就需要重复执行某些语句，以下为大多数编程语言循环程序的流程如：

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中形式，只有其中的一种使用分号，其语法如下所示：

1、和C语言的for一样：

for init; condition; post { }

2、和C的while一样：

for condition { }

3、和C的for(;;)一样：

for { }

• init：一般为赋值表达式，给控制变量赋初值；
• condition：关系表达式或逻辑表达式，循环控制条件；
• post：一般为赋值表达式，给控制变量增量或减量；

for语句执行过程如下：

• 先对表达式赋初值；
• 判别赋值表达式init是否满足给定条件，若其值为true，满足循环条件，则执行循环体内语句，然后执行post，进入第二次循环，再判别condition；否则判别condition的值为false，不满足条件，就终止for循环，执行循环体外语句。

for循环的range格式对slice、map、数组、字符串等进行迭代循环，格式如下：

for key, value := range oldMap {
    newMap[key] = value
}

for语句语法流程图如下所示：

代码实例：

package main

import "fmt"

func main()  {
	var a int
	var b int = 15

	numbers := [6]int{1, 2, 3, 5}

	/* for 循环 */
	for a :=0; a < 10; a++ {
		fmt.Printf("a 的值为：%d\n", a)
	}

	for a < b {
		a++
		fmt.Printf("a 的值为：%d\n", a)
	}

	for i, x:= range numbers{
		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语言允许用户再循环内使用循环，其语法如下：

for [conditon | (init; condition; increment) |Range]{
    for [condition | (init; condition; increment) | Range]{
        statement(s)
    }
    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 是素数

Go语言break语句

Go语言中break语句用于以下两方面：

1、用于循环语句中跳出循环，并开始执行循环之后的语句；

2、break再switch(开关语句)中在执行一条case后跳出语句的作用；

其语法如下所示：

break

break语句流程图如下：

代码实例：

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语句流程图如下所示：

代码实例：

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

Go语言goto语句

Go语言的goto语句可以无条件地转移到过程中指定的行，goto语句通常与条件语句配合使用。可以用来实现条件转移，构成循环，跳出循环体等功能。但是，在结构化程序设计中一般不主张使用goto语句，以免造成程序流程的混乱，使理解和调试都产生困难。goto语法格式如下：

goto label
..
.
label：statement

其流程图如下：

代码实例：

package main

import "fmt"

func main()  {
	/* 定义局部变量 */
	var a int = 10

	/* 循环 */
	LOOP: for a < 20 {
		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