go---流程控制---循环

---

一、if 循环？

1.1 、if 单循环

语法

1.1.2、双分支控制

1.1.3、多分支控制 if … else if …else

1、多分支的判断流程如下:
(1) 先判断条件表达式 1 是否成立，如果为真，就执行代码块 1
(2) 如果条件表达式 1 如果为假，就去判断条件表达式 2 是否成立， 如果条件表达式 2 为真，
就执行代码块 2
(3) 依次类推.
(4) 如果所有的条件表达式不成立，则执行 else 的语句块。
2、else 不是必须的。
3、多分支只能有一个执行入口。

	var b bool = true
	if b == false {  //如果写成 b == false能编译通过吗？ 如果能，结果是?
		fmt.Println("a")
	} else if b {
		fmt.Println("b")
	} else if !b {
		fmt.Println("c")
	} else {
		fmt.Println("d")
	}

	//输出是b
	//如果写成 b= false能便编译通过吗？ 不能，因为if表达式不能是赋值语句为判断条件和python不同 

1.1.4 、嵌套分支

• 在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分
  支外面的分支结构称为外层分支
  

二、switch 分支控制

使用步骤

1、switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上到下逐一测
试，直到匹配为止。
2、 匹配项后面也不需要再加 break

• 请编写一个程序，该程序可以接收一个字符，比如: a,b,c,d,e,f,g a 表示星期一，b 表示星期二 … 根
  据用户的输入显示相依的信息.要求使用 switch 语句完成

	var key byte
	fmt.Println("请输入一个字符， a, b, c, d, e")
	fmt.Scanf("%c", &key)

	switch key {
	case 'a':
		fmt.Println("周一")
	case 'b':
		fmt.Println("周二")
	case 'c':
		fmt.Println("周三")
	case 'd':
		fmt.Println("周四")
	case 'e':
		fmt.Println("周五")
	}

2.1 、switch 的使用的注意事项和细节

case/switch 后是一个表达式( 即：常量值、变量、一个有返回值的函数等都可以)

2.1.2、case 后的各个表达式的值的数据类型，必须和 switch 的表达式数据类型一致

	var n1 int32 = 20
	var n2 int64 = 20 //错误，因为n2数据类型和n1的不一致
	switch n1 {
	case n2:
		fmt.Println("ok1")
	default:
		fmt.Println("没有匹配到")
	}

2.1.3、case 后面可以带多个表达式，使用逗号间隔。比如 case 表达式 1, 表达式 2 …

	var n1 int32 = 5
	var n2 int32 = 20
	switch n1 {
	case n2, 10, 5:  //case 后面可以有多个表达式
		fmt.Println("ok1")
	default:
		fmt.Println("没有匹配到类型")
	}

2.1.4、case 后面的表达式如果是常量值(字面量)，则要求不能重复

	var n1 int32 = 5
	var n2 int32 = 20
	switch n1 {
	case n2, 10, 5: //case 后面可以有多个表达式
		fmt.Println("ok1")
	case 5: //错误，因为前面已经有了常量5，重复就会报错
		fmt.Println("ok2")

	default:
		fmt.Println("没有匹配到类型")
	}

• case 后面不需要带 break , 程序匹配到一个 case 后就会执行对应的代码块，然后退出 switch，如
  果一个都匹配不到，则执行 default
• default 语句不是必须的

2.1.5 、switch 后也可以不带表达式，类似 if --else 分支来使用。

	var age = 10
	switch {
	case age == 10:
		fmt.Println("age==10")
	case age == 20:
		fmt.Println("age==20")
	}

三、switch 和 if 的比较

总结了什么情况下使用 switch ,什么情况下使用 if
1) 如果判断的具体数值不多，而且符合整数、浮点数、字符、字符串这几种类型。建议使用 swtich
语句，简洁高效。
2) 其他情况：对区间判断和结果为 bool 类型的判断，使用 if，if 的使用范围更广

四、for 循环控制

• go的for循环和java的类似

4.1、语法格式

4.1.1、语法格式一

for 循环变量初始化; 循环条件; 循环变量迭代 {
循环操作(语句)
}

-------
eg: 
	for i := 0; i <= 10; i++ {
		fmt.Println("你好")
	}

4.1.2、语法格式二、

for 循环判断条件 {
//循环执行语句
}
将变量初始化和变量迭代写到其它位置
-------------
eg：
	i := 0 //初始化循环变量
	for i < 11 {  //循环条件
		fmt.Println("你好")
		i++
	}

4.1.3 格式三、

for {
//循环执行语句
}

上面的写法等价 for ; ; {} 是一个无限循环， 通常需要配合 break 语句使用


	k := 1
	for {
		if k <= 10 {
			fmt.Println("你好")
		} else {
			// break //和python一样是跳出整个循环
			continue //同python 结束本次循环，继续执行
		}
		k++
	}

格式说明

1) 对 for 循环来说，有四个要素：
2) 循环变量初始化
3) 循环条件
4) 循环操作(语句) ,有人也叫循环体。
5) 循环变量迭代

for 循环执行的顺序说明

1) 执行循环变量初始化，比如 i := 1
2) 执行循环条件， 比如 i <= 10
3) 如果循环条件为真，就执行循环操作 :比如 fmt.Println(“....”)
4) 执行循环变量迭代 , 比如 i++
5) 反复执行 2, 3, 4 步骤，直到 循环条件为 False ，就退出 for 循环。

4.2、举例

4.2.1、遍历字符串

	str := "hello world"
	for i := 0; i < len(str); i++ {
		fmt.Printf("%c \n", str[i])
	}

4.2.2、字符串遍历方式 2-for - range

	str := "hello world"
	str = "abc"
	for index, val := range str {
		fmt.Printf("index=%d, str=%c \n", index, val)
	}
--------------------
	strone := "老王你好啊"
	for index, t := range strone {
		fmt.Printf("index=%d, t=%c \n", index, t)
	}

五、while循环

• Go 语言没有 while 和 do…while 语法，这一点需要同学们注意一下，如果我们需要使用类似其它语
  言(比如 java / c 的 while 和 do…while )，可以通过 for 循环来实现其使用效果

说明上图

1) for 循环是一个无限循环
2) break 语句就是跳出 for 循环

	i := 1
	for {
		if i > 10 {
			break
		} else {
			fmt.Println("hello world")
			i += 1
		}
	}

六、多重循环难点

将一个循环放在另一个循环体内，就形成了嵌套循环。在外边的 for 称为外层循环在里面的 for
循环称为内层循环。【建议一般使用两层，最多不要超过 3 层】
2) 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false
时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
3) 外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m*n 次

七、跳转控制语句-break

• break 语句用于终止某个语句块的执行，用于中断当前 for 循环或跳出 switch 语句
• break 跳出当前所有循环

基本语法

{ ......
break
......
}

	i := 1

	for {
		fmt.Println("hello world")
		i += 1
		if i > 10 {
			break // 直接结束 最外层的for循环
		}
	}

7.1、break可以指定跳出的循环

• break 语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块
• 需要使用关键字: lable 来进行设置

lable2:
	for i := 0; i < 4; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				break lable2 //结束标签lable2 下的所有的
			}
			fmt.Println("j=", j)
		}
	}

对上面案例的说明

(1) break 默认会跳出最近的 for 循环
(2) break 后面可以指定标签，跳出标签对应的 for 循环

八、跳转控制语句-continue

8.1、基本语句介绍

continue 语句用于结束本次循环，继续执行下一次循环。
continue 语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环 , 这
个和前面的 break 标签的使用的规则一样

8.2、基本语法

{ ......
continue
......
}

	for i := 0; i < 4; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				continue
			}
			fmt.Println("j=", j)
		}
	}

• 上面输出是没j == 2的因为跳过了

练习

• continue 实现 打印 1——100 之内的奇数[要求使用 for 循环+continue]

	for i := 0; i <= 100; i++ {
		if i%2 == 0 {
			continue
		}
		fmt.Println("奇数是:", i)
	}

九、跳转控制语句-goto

9.1、goto的基本介绍

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

9.2、 基本语法

goto label
.. .
label: statement

9.3、goto的流程图

案例

	i := 30

	fmt.Println("ok1")
	if i > 20 {
		goto lable1
	}
	fmt.Println("ok2")  // 直接跳过不执行
	fmt.Println("ok3")
	fmt.Println("ok4")
lable1:
	fmt.Println("ok5")
	fmt.Println("ok6")
	fmt.Println("ok7")
	/*
		输入是:
		ok1
		ok5
		ok6
		ok7
	*/

十、跳转控制语句-return

• return 使用在方法或者函数中，表示跳出所在的方法或函数

10.1、说明

1) 如果 return 是在普通的函数，则表示跳出该函数，即不再执行函数中 return 后面代码，也可以
理解成终止函数。
2) 如果 return 是在 main 函数，表示终止 main 函数，也就是说终止程序