Go-06 Golang语言中的流程控制，标签设置label

package main

import "fmt"

/*	...Go语言中的流程控制...	*/
/*	Go语言中的流程控制结构
1. Go 语言中if条件判断的格式如下：
	if 表达式1{
		分支1
	}else if 表达式2{
		分支2
	}else{
		分支3
	}
	解析该if-else条件判断结构如下：
	当表达式1的结果为true时，执行分支1，否则判断表达式2，如果满足则执行分支2，都不满足时，则执行分支3.
	if判断中的else if 和 else 都是可选的，可以根据实际需要进行选择。
	注意：if-else条件判断结构的左括号与if匹配的{必须于if放在同一行。同理，与else匹配的{必须与else放在同一行。
2. for循环结构
	2.1	for循环结构的基本格式如下：
	for 初始语句;条件表达式;结束语句{
		循环体语句
	}
	2.2	for循环条件表达式，满足条件表达式就会不停地进行循环，直到条件表达式不满足时自动退出循环。示例如下：
	for i:= 0; i < 10; i++ {
		fmt.Println(i)
	}
	2.3	for 循环的初始语句可以被忽略，但是初始语句后的分号必须要写，例如：
	i := 0
	for ; i < 10; i++ {
		fmt.Println(i)
	}
	2.4	for 循环的初始语句和结束语句都可以省略，进行一个for循环结构的变形，例如：
	i := 0
	for i < 10 {
		fmt.Println(i)
		i++
	}
	2.5	for 无限循环
	for {
		fmt.Println("没有结束条件，无限循环下去")
	}
	2.6 for 循环可以结合break、goto、return、panic 语句强制退出循环。每个关键字所带有的作用会有不同。
	2.7 for range(键值循环)
		Go语言中可以使用for range 遍历数组、切片、字符串、map、通道(channel)，通过for range遍历的返回值有以下规律：
		2.7.1 数组、切片、字符串返回索引和值
		2.7.2 map返回键和值
		2.7.3 通道(channel) 只返回通道内的值

	2.8 switch case 条件结构
		2.8.1 使用switch语句可方便的对大量的值进行条件判断。Go语言规定每个switch只能有一个default分支。
		2.8.2 Go 语言中每个case语句中可以不写break，不加break也不会出现穿透的现象
		2.8.3 Go 语言中switch case结构中，一个case条件分支可以有多个值，多个值中间使用英文逗号分隔。
		2.8.4 Go 语言中switch 的穿透 fallthrought，在满足条件的case中加上fallthrough,可以执行下一个case语句，
		是为了兼容C语言中的case设计的。示例：
		st := "a"
		switch {
		case st == "a":
			fmt.Println("a")
			fallthrough		// 这个fallthrough 默认只能穿透一层
		case st == "b":
			fmt.Println("b")	// 上面case加了fallthrough,这个case结构也会强制被执行。
		case st == "c":
			fmt.Println("c")
		default:
			fmt.Println("......")
		}
		最终打印结果是：a 和 b

	2.9 break 跳出循环
		2.9.1 用于循环语句中跳出循环，并开始执行循环之后的语句。
		2.9.2 break在switch case结构中起到跳出当前case的作用。
		2.9.3 在多重循环中，可以用标号label标出想break的循环。
                  break labelname的作用，是直接干掉整个循环结构体，结束结构体代码的执行。
                  continue labelname的作用，是直接结束当前循环，然后跳转到labelname命名的地方重新继续执行循环结构体代码，
                  再遇到continue labelname，就再次跳转到labelname命名的地方重新继续执行，直到循环的次数用尽。

		extname := ".js"
		switch extname {
		case ".html":
			fmt.Println("text/html")
			break
		case ".css":
			fmt.Println("text/css")
			break
		case ".js":
			fmt.Println("text/javascript")	// 这个条件满足，它会打印
			break
		default:
			fmt.Println("格式错误")
			break
		}
		2.9.4 for循环中默认break只能跳出一层循环
			for i := 0; i < 3; i++ {
				if i == 2 {
					break
				}
				fmt.Println("打印 i 的值：", i)
			}
			// 这个结果是：
			打印 i 的值： 0
			打印 i 的值： 1
		2.9.5 Go语言中，在多重循环中，可以用标号label标出想break的循环。
label2:		// 这个在函数中的格式是顶格写
	for i := 0; i < 2; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				break label2
			}
			fmt.Println(" i j 的值", i, "_", j)
		}
	}
	// 这个结果是：
	i j 的值 0 _ 0
	i j 的值 0 _ 1
		2.9.6 Go语言中 continue 是继续下一次循环，
		continue 语句可以结束当前循环，开始下一次的循环迭代过程，仅限使用在for循环结构中。
		for m := 0; m < 2; m++ {
			for n := 0; n < 4; n++ {
				if n == 1 {
					continue		// 当 n 的值为1时，跳过本次循环，继续执行下一次循环
				}
				fmt.Println(" m n 的值", m, "_", n)
			}
		}
		// 这个结果是：
		 m n 的值 0 _ 0
		 m n 的值 0 _ 2
		 m n 的值 0 _ 3
		 m n 的值 1 _ 0
		 m n 的值 1 _ 2
		 m n 的值 1 _ 3

		2.9.7 在continue关键字后添加标签时，表示开始标签对应的循环。例如：
suibian:
	for x := 0; x < 2; x++ {
		for y := 0; y < 4; y++ {
			if y == 2 {
				continue suibian
			}
			fmt.Println(" x y 的值", x, "_", y)
		}
	}
	// 这个结果是：
	 x y 的值 0 _ 0
	 x y 的值 0 _ 1
	 x y 的值 1 _ 0
	 x y 的值 1 _ 1

		2.9.8 goto 跳转到指定标签
			goto 语句通过标签进行代码间的无条件跳转。goto 语句可以在快速跳出循环、避免重复退出上有一定的帮助。
			Go 语言中使用goto 语句能简化一些代码的实现过程。
		var n3 int = 30
		fmt.Println("...OK1......OK1...")
		if n3 > 20 {
			goto label33 // 跳转到标签”label33“
		}
		fmt.Println("...OK2......OK2...")
		fmt.Println("...OK3......OK3...")
		fmt.Println("...OK4......OK4...")
label33:
	fmt.Println("...OK5......OK5...")
	fmt.Println("...OK6......OK6...")
	fmt.Println("...OK7......OK7...")
	// 这个结果是：
	...OK1......OK1...
	...OK5......OK5...
	...OK6......OK6...
	...OK7......OK7...

		2.9.9 使用goto语句能简化代码
	for x := 0; x < 2; x++ {
		for y := 0; y < 4; y++ {
			if y == 2 {
				// 设置退出标签 breakTag
				goto breakTag
			}
			fmt.Println(" 最新 x y 的值", x, "_", y)
		}
	}
// 退出标签
breakTag:
	fmt.Println(" 结束for循环 ")
	fmt.Println()
	// 这个结果是：
	 最新 x y 的值 0 _ 0
	 最新 x y 的值 0 _ 1
	 结束for循环

*/

func main() {
	// 1. if 条件判断特殊写法
	// 可以再if表达式之前添加一个执行语句，再根据变量值进行判断，例子如下：
	// 知识点：这个if-else结构中的score变量属于局部作用域。离开if-else结构体去使用会直接报错。
	if score := 56; score >= 90 {
		fmt.Println("AAA")
	} else if score > 75 {
		fmt.Println("BBB")
	} else {
		fmt.Println("CCC") // 条件满足，会被执行
	}
	// 练习1：求两个数的最大值
	var n1 int = 20
	var n2 int = 55
	var max int
	if n1 > n2 {
		max = n1
	} else {
		max = n2
	}
	fmt.Println("max=", max) // max= 55
	// 练习2：判断一个人的成绩，小于60分不及格，大于等于60小于80及格，大于80优秀
	if score := 39; score < 60 {
		fmt.Println("不及格") // 条件满足，会被执行
	} else if score >= 60 && score < 80 {
		fmt.Println("及格")
	} else {
		fmt.Println("优秀")
	}
	// 练习3：不满足条件时，使用 break 结束循环
	k := 1
	for {
		if k <= 3 {
			fmt.Println("ok~~~", k)
		} else {
			break
		}
		k++

	}
	// 练习4：打印0-10所有的偶数
	for i := 0; i < 10; i++ {
		if i%2 == 0 {
			fmt.Println("0-10之间的偶数", i)
		}
	}
	// 练习5：1-100 之间所有是9的倍数的数字，求出并打印，这些整数的个数以及他们的总和
	count := 0
	sum := 0
	for i := 1; i < 100; i++ {
		if i%9 == 0 {
			sum += i
			count++
		}
	}
	fmt.Println("个数count=", count, "总和sum=", sum) // 个数count= 11 总和sum= 594
	// 练习6： 求1+2+3+4+...+100 的和
	sum100 := 0
	for i := 1; i <= 100; i++ {
		sum100 += i
	}
	fmt.Println("sum100=", sum100) // sum100= 5050
	// 练习7： 计算5的阶乘
	var n = 5
	sumj := 1
	for i := 1; i <= n; i++ {
		sumj *= i
	}
	fmt.Println("sumj=", sumj) // sumj= 120
	// 练习8： 打印一个矩形
	for i := 1; i <= 12; i++ {
		fmt.Print("*")
		if i%4 == 0 {
			fmt.Println()
		}
	}
	// 练习8：打印一个四行八列的矩形
	line := 4
	num := 8
	for i := 1; i <= line; i++ {
		for j := 0; j < num; j++ {
			fmt.Print("*")
		}
		fmt.Println()
	}
	// 练习9：打印一个三角形
	line2 := 5
	for i := 1; i <= line2; i++ {
		for j := 1; j <= i; j++ {
			fmt.Print("*")
		}
		fmt.Println()
	}
	// 练习10：打印出99乘法表
	for i := 1; i <= 9; i++ {
		for j := 1; j <= i; j++ {
			fmt.Printf("%dx%d=%d\t", i, j, i*j) // \t就是一个Tab键的距离。
		}
		fmt.Println()
	}
	/*	2. for range(键值循环)
		Go 语言中可以使用for range 遍历数组、切片、字符串、map 及通道(channel)。通过for range遍历的返回值有以下规律：
		2.1 数组、切片、字符串返回索引和值。
		2.2 map 返回键和值。
		2.3 通道(channel)只返回通道内的值。
	*/
	str := "abc 上海"
	for index, value := range str {
		fmt.Printf("index=%d, value=%c \n", index, value)
	}
	str2 := "abc 上海"
	for _, value := range str2 {
		fmt.Printf("value=%c \n", value)
	}
	/*	3. switch case条件判断
		使用switch语句可方便的对大量的值进行条件判断。
		Go语言规定每个switch只能有一个default分支。
	*/
	// 练习：判断文件类型，如果后缀名是.html 输出text/html,如果后缀名是.css 输出text/css,如果后缀名是.js 输出text/javascript
	// 3.1 Go 语言规定每个switch只能有一个default分支。
	extname := ".js"
	switch extname {
	case ".html":
		fmt.Println("text/html")
		break
	case ".css":
		fmt.Println("text/css")
		break
	case ".js":
		fmt.Println("text/javascript")
		break
	default:
		fmt.Println("格式错误") // 这个条件满足，它会打印
		break
	}
	// 3.2 Go 语言中每个case语句中可以不写break，不加break也不会出现穿透的现象，如下例子：
	extname2 := ".a"
	switch extname2 {
	case ".html":
		fmt.Println("text/html")
	case ".css":
		fmt.Println("text/css")
	case ".js":
		fmt.Println("text/javascript")
	default:
		fmt.Println("格式错误") // 这个条件满足，它会打印
	}
	// 3.3 Go 语言中switch case结构中，一个case条件分支可以有多个值，多个值中间使用英文逗号分隔。
	nn := 2
	switch nn {
	case 1, 3, 5, 7, 9:
		fmt.Println("我是奇数")
	case 2, 4, 6, 8:
		fmt.Println("我是偶数") // 这个条件满足，它会打印
	default:
		fmt.Println(nn)
	}
	// 3.3.1 Go 语言中switch case结构的另一种写法：
	switch n := 7; n {
	case 1, 3, 5, 7, 9:
		fmt.Println("奇数")
	case 2, 4, 6, 8:
		fmt.Println("偶数")
	default:
		fmt.Println(n)
	}
	// 3.3.2 Go 语言中switch case结构的另一种写法：
	// switch case 分支还可以使用表达式，这时候switch语句后面不需要再跟判断变量。
	age := 56
	switch {
	case age < 25:
		fmt.Println("好好学习吧")
	case age > 25 && age <= 60:
		fmt.Println("好好工作吧")
	case age > 60:
		fmt.Println("好好享受吧")
	case age > 70 && age <= 85:
		fmt.Println("每天锻炼一小会")
	default:
		fmt.Println("活着真好！")
	}
	// 3.3.3 switch 的穿透 fallthrought
	// 在满足条件的case中加上fallthrough,可以执行下一个case语句，是为了兼容C语言中的case设计的。
	st := "a"
	switch {
	case st == "a":
		fmt.Println("a")
		fallthrough // 这个fallthrough 默认只能穿透一层
	case st == "b":
		fmt.Println("b") // 上面case加了fallthrough,这个case结构也会强制被执行。
	case st == "c":
		fmt.Println("c")
	default:
		fmt.Println("......")
	}
	// 3.3.4 switch 的穿透 fallthrough ,默认只能穿透一层，根据这个特性，写一个例子
	var num2 int = 10
	switch num2 {
	case 10:
		fmt.Println("OK1") // 这个会被执行
		fallthrough
	case 20:
		fmt.Println("OK2") // 这个也会被执行
		fallthrough
	case 30:
		fmt.Println("OK3") // 这个也会被执行
	default:
		fmt.Println("...没有匹配到...")
	}
	// 4. for循环中默认break 只能跳出一层循环
	for i := 0; i < 3; i++ {
		if i == 2 {
			break
		}
		fmt.Println("打印 i 的值：", i)
	}
	// 4.1 通过break结束for循环
	kk := 1
	for {
		if kk <= 10 {
			fmt.Println("OK~~~", kk)
		} else {
			break // 当kk=11时，条件不满足就会跳出这个for循环
		}
		kk++
	}
	// 4.2 在多重循环中，可以用标号label标出想break的循环。
label2:
	for i := 0; i < 2; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				break label2    // 只要遇到这个break + label会直接干掉整个循环结构体的执行
			}
			fmt.Println(" i j 的值", i, "_", j)
		}
	}
	fmt.Println()
	// 4.3 continue 语句可以结束当前循环，继续下一次循环，仅限使用在for循环结构中。
	for m := 0; m < 2; m++ {
		for n := 0; n < 4; n++ {
			if n == 1 {
				continue
			}
			fmt.Println(" m n 的值", m, "_", n)
		}
	}
	fmt.Println()
	// 4.4 在continue关键字后添加标签时，表示开始标签对应的循环。例如：
suibian:
	for x := 0; x < 2; x++ {
		for y := 0; y < 4; y++ {
			if y == 2 {
				continue suibian  // 遇到这个continue + label会直接跳过当前循环，跳转到label定义的地方，然后再次进入循环结构体中进行代码的执行。
                                // 这里面就是遇到continue suibian 代码体后，就会直接跳转到suibian这个标签定义的地方，然后继续执行for循环结构体代码，继续根据条件判断执行相关的代码。
			}
			fmt.Println(" x y 的值", x, "_", y)
		}
	}
	fmt.Println()
	// 4.5 goto跳转到指定标签
	/*	4.5 goto跳转到指定标签
		goto 语句通过标签进行代码间的无条件跳转。goto语句可以在快速跳出循环、避免重复退出上有一定的帮助。
		Go 语言中使用goto语句能简化一些代码的实现过程。
	*/
	var n3 int = 30
	fmt.Println("...OK1......OK1...")
	if n3 > 20 {
		goto label33 // 跳转到标签”label33“
	}
	fmt.Println("...OK2......OK2...")
	fmt.Println("...OK3......OK3...")
	fmt.Println("...OK4......OK4...")
label33:
	fmt.Println("...OK5......OK5...")
	fmt.Println("...OK6......OK6...")
	fmt.Println("...OK7......OK7...")
	fmt.Println()
	// 4.6 使用 goto 能简化代码
	for x := 0; x < 2; x++ {
		for y := 0; y < 4; y++ {
			if y == 2 {
				// 设置退出标签
				goto breakTag
			}
			fmt.Println(" 最新 x y 的值", x, "_", y)
		}
	}
	// 退出标签
breakTag:
	fmt.Println(" 结束for循环 ")
	fmt.Println()

	// ***********end*************
	/*	上面所有代码执行的结果如下：
		PS C:\Users\Zhaoshan.lu\go\DaDi> go run .\08.go
		CCC
		max= 55
		不及格
		ok~~~ 1
		ok~~~ 2
		ok~~~ 3
		0-10之间的偶数 0
		0-10之间的偶数 2
		0-10之间的偶数 4
		0-10之间的偶数 6
		0-10之间的偶数 8
		个数count= 11 总和sum= 594
		sum100= 5050
		sumj= 120
		****
		****
		****
		********
		********
		********
		********
		*
		**
		***
		****
		*****
		1x1=1
		2x1=2   2x2=4
		3x1=3   3x2=6   3x3=9
		4x1=4   4x2=8   4x3=12  4x4=16
		5x1=5   5x2=10  5x3=15  5x4=20  5x5=25
		6x1=6   6x2=12  6x3=18  6x4=24  6x5=30  6x6=36
		7x1=7   7x2=14  7x3=21  7x4=28  7x5=35  7x6=42  7x7=49
		8x1=8   8x2=16  8x3=24  8x4=32  8x5=40  8x6=48  8x7=56  8x8=64
		9x1=9   9x2=18  9x3=27  9x4=36  9x5=45  9x6=54  9x7=63  9x8=72  9x9=81
		index=0, value=a
		index=1, value=b
		index=2, value=c
		index=3, value=
		index=4, value=上
		index=7, value=海
		value=a
		value=b
		value=c
		value=
		value=上
		value=海
		text/javascript
		格式错误
		我是偶数
		奇数
		好好工作吧
		a
		b
		OK1
		OK2
		OK3
		打印 i 的值： 0
		打印 i 的值： 1
		OK~~~ 1
		OK~~~ 2
		OK~~~ 3
		OK~~~ 4
		OK~~~ 5
		OK~~~ 6
		OK~~~ 7
		OK~~~ 8
		OK~~~ 9
		OK~~~ 10
		 x y 的值 0 _ 0
		 x y 的值 0 _ 1
		 x y 的值 1 _ 0
		 x y 的值 1 _ 1

		...OK1......OK1...
		...OK5......OK5...
		...OK6......OK6...
		...OK7......OK7...

		 最新 x y 的值 0 _ 0
		 最新 x y 的值 0 _ 1
		 结束for循环

		PS C:\Users\Zhaoshan.lu\go\DaDi>

	*/
}