golang for 循环

1.for 循环

for循环是Golang唯一的循环语句。

for 初始表达式; 布尔表达式; 迭代因子 {

循环体;

}

package main

import "fmt"

func main() {
	for i := 0; i < 5; i++ { //定义i变量值为0，判断i的值小于5执行下面的打印，每次i的值为i=i+1
		fmt.Printf("i的值为:%v\n", i)
	}
}

执行结果

i的值为:0
i的值为:1
i的值为:2
i的值为:3
i的值为:4

循环字符串

package main

import "fmt"

func main() {
	var s1 string = "hello,world"
	l1 := len(s1) //按照字符串的字节长度
	fmt.Printf("s1的长度为：%v\n", l1)
	for i := 0; i < len(s1); i++ {
		fmt.Printf("i[%d]的值为：%c\n", i, s1[i]) //每次字节的值为s1[0-11]
	}
}

执行结果

s1的长度为：11
i[0]的值为：h
i[1]的值为：e
i[2]的值为：l
i[3]的值为：l
i[4]的值为：o
i[5]的值为：,
i[6]的值为：w
i[7]的值为：o
i[8]的值为：r
i[9]的值为：l
i[10]的值为：d

注意：如果我们的字符串含有中文，那么传统的遍历字符串方式，就是错误，会出现乱码。原因是传统的对字符串的遍历是按照字节来遍历，而一个汉字在 utf8 编码是对应 3 个字节。解决方式，将字符串转成切片再进行遍历

package main

import "fmt"

func main() {
	var s1 string = "hello,世界"
	s2 := []rune(s1) //将s1字符串转成切片。
	for i := 0; i < len(s2); i++ { //循环切片下标，打印下标对应的值
		fmt.Printf("key=%d,val=%c\n", i, s2[i])
	}
}

执行结果

key=0,val=h
key=1,val=e
key=2,val=l
key=3,val=l
key=4,val=o
key=5,val=,
key=6,val=世
key=7,val=界

2.for 死循环

func main() {
	//第一种写法
	for {
		fmt.Println("hello,world")
	}
	//第二种写法
	for ;;{
		fmt.Println("hello,world")
	}
}

输出结果

hello,world
hello,world
hello,world
.......

3.for range循环(键值循环)

for range 可以遍历数组、切片、字符串、map 及通道，for range 语法上类似于其它语言中的 foreach 语句，一般形式为：

for key, val := range coll {

...

}

• range 返回一个值的时候，默认为key（下标），返回两个值的时候为key（下标），val（下标对应的值）
• 遍历map时为随机输出，slice则为索引顺序输出

使用for lang打印字符串

package main

import "fmt"

func main() {
	var s1 string = "hello,世界"
	for key, val := range s1 { //key为索引值，val为具体的索引对应的值
		fmt.Printf("key=%d,val=%c\n", key, val)
	}
}

执行结果

世的对应下标为6

界的对应下标为9

因为一个中文用三个字节，世对应的下标为（6,7,8）界（9,10,11）只输出了开头的下标。

key=0,val=h
key=1,val=e
key=2,val=l
key=3,val=l
key=4,val=o
key=5,val=,
key=6,val=世
key=9,val=界

4.for 循环中的关键字

4.1 break

表示停止当前循环

4.1.1 单次循环

package main

import "fmt"

func main() {
	for i := 0; i < 10; i++ {
		if i == 6 { //当i=6时执行下面的代码
			break //终止本次循环
		}
		fmt.Println(i)
	}
}

执行结果

当i等于6时，if条件成立，执行break终止了本次循环，所以不会继续执行循环。

0
1
2
3
4
5

break 标签

使用label语句,给需要停止的循环加标签，如：label1，然后break label1即可以停止当前循环。

package main

import "fmt"

func main() {
label1: //给一层循环加标签label1
	for i := 0; i < 4; i++ { //第一层循环
		for j := 0; j < 3; j++ { //第二层循环
			if i == 2 && j == 1 { //当循环i等于2，j等于1终止本次第二层循环
				//break在第二层循环语句内，默认终止第二层的本次循环，第一层循环还会继续执行
				break label1 //终止第一层循环，当i等于2，j等于1的时候，终止第一次循环，第一次循环内的语句也不会继续执行了
			}
			fmt.Printf("i的值为：%v，j的值为：%v\n", i, j)
		}
	}
}

执行结果

默认在第二次循环使用break不加标签，只会终止第二层循环，还会继续输出i等于3时j的值

当break加上标签，终止了第一层循环后，当i等于2，j等于1时，第一层循环终止了，所以不会执行后面i等于3的结果。

i的值为：0，j的值为：0
i的值为：0，j的值为：1
i的值为：0，j的值为：2
i的值为：1，j的值为：0
i的值为：1，j的值为：1
i的值为：1，j的值为：2
i的值为：2，j的值为：0

4.2 continue

4.2.1 单次循环

跳过本次循环，执行下一次循环

package main

import "fmt"

func main() {
	for i := 0; i < 10; i++ {
		if i == 6 { //当i=6时执行下面的代码
			continue //跳过本次循环,继续执行本地循环的下一次循环
		}
		fmt.Println(i)
	}
}

执行结果

0
1
2
3
4
5
7
8
9

4.2.2 continue 标签

使用label语句,给需要跳过的循环加标签，如：label1，continue label1即可以跳过本地循环，执行下一次循环

package main

import "fmt"

func main() {
label1: //给一层循环加标签label1
	for i := 0; i < 4; i++ { //第一层循环
		for j := 0; j < 3; j++ { //第二层循环
			if i == 2 && j == 1 { //当循环i等于2，j等于1跳过本次第二层循环
				//continue在第二层循环语句内，默认跳过第二层的本次循环，继续执行第二层循环的下一次循环
				continue label1 //跳过第一层循环，当i等于2，j等于1的时候，跳过第一次循环，继续执行第一层循环的下一次循环
			}
			fmt.Printf("i的值为：%v，j的值为：%v\n", i, j)
		}
	}
}

执行结果

默认在第二次循环使用continue不加标签，只会终止第二层循环，还会继续输出i等于2j等于2。

当continue加上标签，跳过了第一层循环后，当i等于2，j等于1时，第一层循环跳过了，所以不会执行后面i等于2，j等于2的结果。

i的值为：0，j的值为：0
i的值为：0，j的值为：1
i的值为：0，j的值为：2
i的值为：1，j的值为：0
i的值为：1，j的值为：1
i的值为：1，j的值为：2
i的值为：2，j的值为：0
i的值为：3，j的值为：0
i的值为：3，j的值为：1
i的值为：3，j的值为：2

4.3 goto

通过标签进行代码间的无条件跳转。（跳转到需要执行的代码行）goto语句可以在快速跳出循环、避免重复退出上有一定的帮助。Go语言中使用goto语句能简化一些代码的实现过程。 例如双层嵌套的for循环要退出时：

package main

import "fmt"

func main() {
	for i := 1; i < 4; i++ {
		for j := 1; j < 3; j++ {
			if i == 2 && j == 2 {
				goto lable1 //当循环i等于2，j等于2的时候直接跳转到标签lable1对应的代码处
			}
			fmt.Printf("i的值为：%v，j的值为：%v\n", i, j)
		}
	}
lable1:
	fmt.Println("goto跳转执行了")
}

执行结果

i的值为：1，j的值为：1
i的值为：1，j的值为：2
i的值为：2，j的值为：1
goto跳转执行了

4.4 return

在for循环中使用retuen,直接结束当前函数。

package main

import "fmt"

func main() {
	for i := 1; i < 4; i++ {
		for j := 1; j < 3; j++ {
			if i == 2 && j == 2 {
				return //结束当前函数
			}
			fmt.Printf("i的值为：%v，j的值为：%v\n", i, j)
		}
	}
	fmt.Printf("main函数还在执行")
}

执行结果

当i等于2，j等于2时，直接执行return，结束了main函数，所以不会执行函数中的打印

i的值为：1，j的值为：1
i的值为：1，j的值为：2
i的值为：2，j的值为：1