7 控制结构

[TOC]

控制结构

go运行时从main函数开始逐条向下执行，通过一些内置语法糖进行分支跳转，如有条件的跳转if else，无条件跳转go to。

for 循环

go 内置的循环语法糖只有 for 循环一种，没有while、do while

• 可以通过 break 打断当前层for循环。

• continue 跳过当前次循环。

• for {}

func main() {
	i := 0
	for {
		i++
		if 50 == i {
		    continue // 跳出这次循环不往下执行
		}
		fmt.Printf("第%d次循环\n",i)
		if 100 == i {
			break // 打断循环
		}
	}
}

• for 条件 {}

func main() {
	i := 0
	// 循环100次结束
	for i<100 {
		i++
		fmt.Printf("第%d次循环\n",i)
	}
}

• for 表达式1;条件;表达式2 {}

func main() {
	for i:=0;i<100; {
		i++
		fmt.Printf("第%d次循环\n",i)
	}
	// 或者
	for i:=0;i<100;i++ {
		fmt.Printf("第%d次循环\n",i)
	}
}

• for k,v := range 集合{}

• 集合可以是数组、slice、string、map、chan。

func main() {
	// 遍历数组
	arr := [...]int{3,4,5,6}
	for inx,ele := range arr {
		fmt.Printf("索引%d，元素%d\n",inx,ele)
	}
	// 遍历map
	mp := make(map[string]int)
	mp["键1"] = 100
	mp["键2"] = 900
	for key,val := range mp{
		fmt.Printf("键%s，值=%d\n",key,val)
	}
}

条件判断 if else

条件判断

• if 条件 {}

	a := 10
	if a == 10 {
		fmt.Println("条件成立")
	}

• if 表达式;条件 {}

	a := 10
	if b := 8;a == b{ // b变量作用域在if{}中
		fmt.Printf("条件成立")
	}

• if 条件 {} else if {} else {}

	if a == 5{
		fmt.Println("a==5条件成立")
	}else if a == 10{
		fmt.Println("a==10条件成立")
	}else{
		fmt.Println("a以上条件都不成立执行else")
	}

switch

switch根据传入参数执行符合条件的分支。

• case检测条件进入分支，可以使用“,”隔开配置多个条件。

• case后面不需要break，fallthrough击穿执行下一层case。

• default语句在所有case不符合条件时执行default。

• switch

	num := 90
	switch num { // switch num := 90;num { 这样定义num将在switch{}作用域中
		case 80:
			fmt.Println("符合条件80")
		case 90:
			fmt.Println("符合条件90")
			fallthrough	// 击穿执行到下一层
		case 100:
			fmt.Println("符合条件100")
		default:
			fmt.Println("所有条件不符合 执行default")
	}

标签和跳转 break、continue、goto

使用标签标识一个位置（必须在函数内），用于break、continue、goto跳转。

• break 从 for、switch、select中跳转到标签。多用于打断多重循环，break跳转到循环外标签是不会再进循环。

func main() {
	i := 0
	lab:
	for {
		for {
			i++
			fmt.Printf("第%d循环\n",i)
			if 10 == i {
				break lab   // 跳转到lab，不会再进来
			}
		}
	}
	fmt.Println("出for结束")
}

• continue 跳出当前次循环，跳转到外层标签但依然会再次进入循环。

func main() {
	i := 0
	lab:
	for {
		fmt.Println("外层")
		for {
			i++
			time.Sleep(1000)
			fmt.Printf("第%d循环\n",i)
			if i % 4 == 0 {
				continue // 跳出本次
			}
			if 5 == i {
				fmt.Println("continue")
				continue lab	// 调到外层lab，但是会再次进来
			}
		}
	}
	fmt.Println("出for结束")	// 永远都不可能执行这里，前面将是死循环
}

• goto 跳转到函数内任何位置

func main() {
	fmt.Println("测试goto")
	goto end
	// 以下两句都不会执行
	fmt.Println("第一句")
	fmt.Println("第二句")
	// goto直接跳转到这里
	end:
	fmt.Println("结束")
}

return 结束函数、方法的执行

return 也会引发控制流程的跳转，用于函数、方法的退出并可携带返回值。

• return需要注意的是它并不是一个原子性操作，这在一个函数或方法中return与defer一起使用时会有一个陷阱。

func testReturn(){
	a := 10
	if a == 10 {
		return // 结束函数，后面的都不会再执行
	}
	fmt.Println("return测试")
}
func main() {
	testReturn()
}