DAY07:流程控制;if、switch的使用;for、while;控制语句

流程控制

基本介绍

在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句。

• 顺序控制

• 分支控制

• 循环控制

顺序控制

基本介绍

程序从上到下逐行地执行，中间没有任何判断和跳转。

分支控制 if-else

基本介绍

分支控制就是让程序有选择执行。有下面三种形式

1. 单分支

2. 双分支

3. 多分支

单分支控制

基本语法

if 条件表达式{

执行代码块

}

说明:当条件表达式为ture 时，就会执行们的代码注意份是必须有的，就算你只写一行代码。

使用案例1

编写一个程序.可以输入人的年龄,如果该同志的年龄大于 18 岁则输出 你年龄大于 18.要对自己的行为负责!

package main

import "fmt"

func main() {
	var age int
	fmt.Println("请输入你的年龄")
	fmt.Scanln(&age)

	if age > 18 {
		fmt.Println("你年龄大于 18.要对自己的行为负责")
	}
}

使用案例2

在控制语句中直接定义变量

package main

import "fmt"

func main() {
	if a := 19; a > 18 {
		fmt.Println("a大于18")
	}

}

双分支控制

基本语法

if 条件表达式 {

执行代码块1

} else {

执行代码块2

}

说明:当条件表达式成立，即执行代码块1，否则执行代码块2。 也是必须有的

使用案例

编写一个程序可以输入人的年龄.如果该同志的年龄大于 18 岁.则输出 “你年龄大于 18.要对自己的行为负责!”。否则 .输出”你的年龄不大这次放过你了”

package main

import "fmt"

func main() {
	var age int
	fmt.Println("请输入你的年龄")
	fmt.Scanln(&age)

	if age > 18 {
		fmt.Println("你年龄大于 18.要对自己的行为负责!")
	} else {
		fmt.Println("你的年龄不大这次放过你了")
	}
}

单双分支练习

使用案例1

编写程序，声明 2个 int32 型变量并赋值。判断两数之和，如果大于等于 50，打印“hello world!

package main

import "fmt"

func main() {
	var num int32 = 1
	var num2 int32 = 50

	if num+num2 >= 50 {
		fmt.Println("hello world!")
	}
}

使用案例2

定义两个变量 int32，判断二者的和，是否能被 3 又能被 5 整除，打印提示信息

package main

import "fmt"

func main() {
	var num int32 = 1
	var num2 int32 = 14

	if (num+num2)%3 == 0 && (num+num2)%5 == 0 {
		fmt.Println("hello world!")
	}
}

多分支控制

基本语法

if 条件表达式 {

执行代码块1

} else if 条件表达式 {

执行代码块2

} else {

执行代码块3

}

使用案例

小明参加 Golang 考试，他和父亲岳不群达成承诺:

如果:成绩为 100 分时，奖励一辆 BMW;成绩为(80，99]时，奖励一台 iphone;

当成绩为[60.80]时，奖励一个 iPad;

其它时，什么奖励也没有。

请从键盘输入岳小鹏的期末成绩，并加以判断

package main

import "fmt"

func main() {
	var num int
	fmt.Println("请输入小明的成绩")
	fmt.Scanln(&num)

	if num > 80 && num <= 99 {
		fmt.Println("奖励一台 iphone")
	} else if num >= 60 && num <= 80 {
		fmt.Println("奖励一个 iPad")
	} else {
		fmt.Println("什么都不奖励")
	}
}

嵌套分支

基本介绍

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

基本语法

if 条件表达式 {

if 条件表达式 {

执行代码块1

}

}

使用案例

参加百米运动会，如果用时 8 秒以内进入决赛，否则提示淘汰。并且根据性别提示进入男子组或女子组。输入成绩和性别。

package main

import "fmt"

func main() {
	var num float64
	var gen string
	fmt.Println("请输入时间")
	fmt.Scanln(&num)
	fmt.Println("请输入性别")
	fmt.Scanln(&gen)

	if num <= 8 {
		if gen == "男" {
			fmt.Println("进入男子组决赛")
		} else {
			fmt.Println("进入女子组决赛")
		}
	} else {
		fmt.Println("你被淘汰了")
	}
}

switch的使用

基本介绍

1. switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上到下逐一测试，直到匹配为止。

2. 匹配项后面也不需要再加 break

基本语法

基本语法

使用案例

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

package main

import "fmt"

func main() {
	var key byte
	fmt.Println("请输入a,b,c,d.e,f,g")
	fmt.Scanf("%c", &key)

	switch key {
	case 'a':
		fmt.Println("周一")
	case 'b':
		fmt.Println("周二")
	default:
		fmt.Println("输入错误")
	}
}

注意事项

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

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

3. case 后面可以带多个表达式，使用逗号间隔。比如 case 表达式 1，表达式 2...

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

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

6. default 语不是必须的

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

8. switch 后也可以直接声明/定义一个变量，分号结束，不推荐

9. switch 穿透-fallthrough ，如果在 case 语句块后增加 fallthrough,则会继续执行下一个 case，也叫 switch 穿透,默认只穿透一层

10. Type Switch: switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际指向的变量类型

package main

import "fmt"

func main() {
	// case/switch 后是一个表达式( 即: 常量值、变量、一个有返回值的函数等都可以)
	var num1 int
	fmt.Println("输入一个数字")
	fmt.Scanln(&num1)
	switch num1 {
	case 1 + 1:
		fmt.Println("数字2")
	default:
		fmt.Println("不是2")
	}
	//case 后的各个表达式的值的数据类型，必须和 switch 的表达式数据类型一致
	var num2 int32 = 2
	switch num1 {
	case int(num2):
		fmt.Println("数据类型必须一致，所以要转换")
	default:
		fmt.Println("数据类型一致")
	}
	// case 后面可以带多个表达式，使用逗号间隔。比如 case 表达式 1，表达式 2...
	var num3 = 2
	switch num1 {
	case 1, num3:
		fmt.Println("可以有多个表达式")
	default:
		fmt.Println("进入default")
	}
	// switch 后也可以不带表达式，类似 if--else 分支来使用。
	switch {
	case num1 == 2:
		fmt.Println("2")
	default:
		fmt.Println("!2")
	}
	//switch 后也可以直接声明/定义一个变量，分号结束，不推荐
	switch i := 2; {
	case num1 == i:
		fmt.Println("声明的是2")
	default:
		fmt.Println("声明的不是2")
	}
	//switch 穿透-fallthrough ，如果在 case 语句块后增加 fallthrough,则会继续执行下一个 case，也叫 switch 穿透
	switch num1 {
	case 2:
		fmt.Println("穿透这个2")
		fallthrough
	case 3:
		fmt.Println("穿透了！！")
	default:
		fmt.Println("又穿透了")
	}
	//Type Switch: switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际指向的变量类型
	var x interface{}
	var y = 10.0
	x = y
	switch i := x.(type) {
	case nil:
		fmt.Println("nil", i)
	case float64:
		fmt.Println("float64类型")
	default:
		fmt.Println("default")
	}

}

练习

根据用户指定月份，打印该月份所属的季节。3.4,5 春季 6,7,8 夏季 9,10,11 秋季 12,1,2 冬

package main

import "fmt"

func main() {
	var mouth int
	fmt.Println("输入一个月份")
	fmt.Scanln(&mouth)
	switch mouth {
	case 3, 4, 5:
		fmt.Println("春季")
	case 6, 7, 8:
		fmt.Println("夏季")
	case 9, 10, 11:
		fmt.Println("秋季")
	case 12, 1, 2:
		fmt.Println("冬季")
	default:
		fmt.Println("没有这个月份")
	}
}

if和switch的比较

1. 如果判断的具体数值不多，而且符合整数、浮点数、字符、字符串这几种类型。建议使用 swtich语句，简洁高效。

2. 其他情况:对区间判断和结果为 bool类型的判断，使用 if,if 的使用范围更广

for循环

基本语法

使用方法1:

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

使用方法2:

func main() {
	i := 1
	for i < 10 {
		fmt.Println("你好")
		i++
	}
}

使用方法3:

func main() {
	i := 1
	// 这两种写法等价
	//for {
	//
	//}
	for ; ; {
		if i < 5 {
			fmt.Println("你好")
			i++
		} else {
			break
		}
	}
}

注意事项

1. 循环条件是返回一个布尔值的表达式

2. Golang 提供 for-range 的方式，可以方便遍历字符串和数组

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

4. 对应 for-range 遍历方式而言，是按照字符方式遍历。因此如果有字符串有中文，也是 ok

package main

import "fmt"

func main() {
	var str = "helloWorld北京"

	for i := 0; i < len(str); i++ {
		fmt.Printf("%c", str[i]) // 利用下标取值
	}
	// for-range方式
	for index, val := range str {
		fmt.Printf("index =%v, val=%c \n", index, val)
	}
	fmt.Println("\n")
	// 解决乱码，利用切片
	str2 := []rune(str)
	for i := 0; i < len(str2); i++ {
		fmt.Printf("%c", str2[i]) // 利用下标取值
	}
}

使用案例

打印 1~100 之间所有是 9 的倍数的整数的个数及总和

package main

import "fmt"

func main() {
	var sum int

	var count int

	for i := 1; i <= 100; i++ {
		if i%9 == 0 {
			sum += i
			count++
		}
	}

	fmt.Printf("sum=%v, count=%v", sum, count)
}

while和do while

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

多重循环控制

基本介绍

1. 将一个循环放在另一个循环体内，就形成了嵌套循环。在外边的 for 称为外层循环在里面的 for循环称为内层循环。建议一般使用两层，最多不要超过 3 层

2. 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。

3. 外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m*n 次

使用案例

打印金字塔经典案例

package main

import "fmt"

func main() {
	for i := 1; i <= 10; i++ {
		// 打印空格
		for j := 1; j <= 10-i; j++ {
			fmt.Print(" ")
		}
		for z := 1; z <= 2*i-1; z++ {
			fmt.Print("*")
		}
		fmt.Println()
	}
}

使用案例

打印出九九乘法表

package main

import "fmt"

func main() {
	for i := 1; i <= 9; i++ {
		for j := 1; j <= i; j++ {
			fmt.Printf("%v * %v = %v \t", i, j, i*j)
		}
		fmt.Println()
	}
}

控制语句 break

基本介绍

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

基本语法

基本语法

使用案例

随机生成 1-100 的一个数，直到生成了 99 这个数，看看你一共用了几次?

package main

import (
	"fmt"
	"math/rand"
)

func main() {
	var count = 0

	var num int
	for {
		num = rand.Intn(100) + 1
		if num == 99 {
			break
		}
		count++
	}
	fmt.Printf("count = %v; num = %v", count, num)
}

注意事项

1. break 语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块

2. break 默认会跳出最近的for循环

package main

import "fmt"

func main() {
lable1:
	for i := 0; i < 2; i++ {
		fmt.Println("进入第一层")
		for k := 0; k < 2; k++ {
			if i == 1 {
				fmt.Println("进入第二层==2")
				break lable1
			} else {
				fmt.Println("进入第二层")
			}
		}
	}
}

控制语句 continue

基本介绍

1. continue 语句用于结束本次循环，继续执行下一次循环

2. continue 语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的 break 标签的使用的规则一样

基本语法

基本语法

使用案例

某人有 100000 元,每经过一次路口，需要交费,规则如下，当现金>50000 时,每次交 5%，当现金<=50000 时,每次交 1000，编程计算该人可以经过多少次路口,使用 for break 方式完成

package main

import "fmt"

func main() {
	var num float64 = 100000

	var count = 0

	for i := 0; num > 1000; i++ {
		if num > 50000 {
			num -= num * 0.05
			count++
			continue
		} else if num <= 50000 {
			num -= 1000
			count++
			continue
		} else {
			fmt.Println(i)
			break
		}
	}
	fmt.Println(count)
}

控制语句 goto

基本介绍

1. Go 语言的 goto 语句可以无条件地转移到程序中指定的行。

2. goto 语句通常与条件语句配合使用。可用来实现条件转移，跳出循环体等功能。

3. 在 Go 程序设计中一般不主张使用 oto 语句， 以免造成程序流程的混乱，使理解和调试程序

基本语法

基本语法

使用案例

package main

import "fmt"

func main() {
	fmt.Println("ok1")
	fmt.Println("ok2")
	goto lable1
	fmt.Println("ok3")
	fmt.Println("ok4")
lable1:
	fmt.Println("ok5")
	fmt.Println("ok6")
}

控制语句 return

基本介绍

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

使用案例

package main

import "fmt"

func main() {
	for i := 0; i < 10; i++ {
		if i == 2 {
			fmt.Println("==2")
			return
		} else {
			fmt.Println(i)
		}
	}
}

注意事项

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

2. 如果 return 是在 main 函数，表示终止 main 函数，也就是说终止程序。

package main

import "fmt"

func main() {
	fmt.Println("111")
	fmt.Println("222")
	return
	fmt.Println("333")
	fmt.Println("444")
}