go 流程控制-分支

流程控制介绍

在程序中,程序运行得流程控制决定程序是如何执行的,主要有三大流程控制语句

• 顺序控制
• 分支控制
• 循环控制

顺序控制

程序从上到下逐行地执行

分支控制

分支控制是让程序有选择的执行,有三种形式

• 单分支
• 双分支
• 多分支

单分支

语法

if 表达式 {
    执行代码块
}

说明: 当表达式的值为true时,执行{}中的代码
{}是必须有的

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

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

    // golang支持在if中,直接定义一个变量
	if age := 20; age > 18 {
		fmt.Println("你的年龄大于18,要对自己的行为负责!")
	}

双分支

语法

if 表达式 {
    代码块1
} else {
    代码块2
}

说明: 当表达式成立,执行代码块1,否则执行代码块2. {} 是必须有的

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

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

func main()  {
	var x int = 4
	var y int = 1
	if (x > 2) {
		if (y > 2) {
			fmt.Println(x+y)
		}
			fmt.Println("atguigu")
	} else {
		fmt.Println("x is =", x)
	}
}

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

func main()  {
	var n1 int32 = 30
	var n2 int32 = 40
	if n1 + n2 > 50 {
		fmt.Println("hello world!")
	}
}

编写程序,声明2个float64型变量并赋值.判断第一个数大于10.0, 且第二个数小于20.0,打印两数之和

func main()  {
	var n1 float64 = 13.2
	var n2 float64 = 15.4
	if n1 > 10.0 && n2 < 20.0 {
		fmt.Println(n1 + n2)
	}
}

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

func main()  {
	var num1 int32 = 11
	var num2 int32 = 20
	if (num1 + num2) % 3 == 0 && (num1 + num2) % 5 ==0  {
		fmt.Println("能被3又能被5整除")
	}
}

判断一个年份是否是闰年,闰年的条件是符合下面二者之一:(1)年份能被4整除,但不能被100整除; (2)能被400整除

func main()  {
	var year int = 2000
	if  (year % 4 == 0 && year % 100 != 0) || year % 400 == 0 {
		fmt.Printf("%d是闰年!", year)
	}
}

多分支

只有一个分支的代码块会执行

语法

if 表达式1 {
	代码块1
} else if 表达式2 {
	代码块2
}
...
else {
	代码块n
}

package main

import "fmt"

func main()  {
	var score int
	fmt.Println("请输入成绩:")
	fmt.Scanln(&score)
	if score == 100 {
		fmt.Println("优秀")
	} else if score > 80 && score <= 99 {
		fmt.Println("良好")
	} else if score >=60 && score <= 80 {
		fmt.Println("合格")
	} else {
		fmt.Println("不合格")
	}
}

func main()  {
	var n int = 10
	if n > 9 {
		fmt.Println("ok1")
	} else if n > 6 {
		fmt.Println("ok2")
	} else if n > 3 {
		fmt.Println("ok3")
	} else {
		fmt.Println("ok4")
	}
}

运行结果

ok1

注: if的表达式不能是赋值语句

求ax^2+bx+c=0 方程的根. a,b,c分别为函数的参数,如果:b^{2-4ac>0,则有两个解;b}2-4ac=0,则有一个解; b^2-4ac<0,则无解
x1=(-b+sqrt(b^2-4ac))/2a
x2=(-b-sqrt(b^2-4ac))/2a

package main

import (
	"fmt"
	"math"
)

func main()  {
	var a float64 = 3
	var b float64 = 100
	var c float64 = 6
	m := b * b - 4 * a * c

	if m > 0 {
		x1 := (-b + math.Sqrt(m))/ 2 * a
		x2 := (-b - math.Sqrt(m))/ 2 * a
		fmt.Printf("x1=%v, x2=%v", x1, x2)
	} else if m == 0 {
		x1 := (-b + math.Sqrt(m))/ 2 * a
		fmt.Printf("x1=%v", x1)
	} else {
		fmt.Println("无解")
	}
}

嵌套分支

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

语法

if 表达式 {
	if 表达式 {
	} else {
	}
}

说明: 嵌套分支不宜过多,建议控制在3层内

package main

import "fmt"

func main()  {
	var second float64
	fmt.Println("请输入秒数:")
	fmt.Scanln(&second)

	if second <= 8 {
		var gender string
		fmt.Println("请输入性别:")
		fmt.Scanln(&gender)
		if gender == "男" {
			fmt.Println("进入决赛男子组")
		} else {
			fmt.Println("进入决赛女子组")
		}
	} else {
		fmt.Println("out...")
	}
}

出票系统: 根据淡旺季的月份和年龄,打印票价
旺季(4-10月):
成人(18-60): 60
儿童(<18): 半价
老人(>60): 1/3价
淡季:
成人: 40
其他: 20

package main

import (
	"fmt"
)

func main()  {
	var month byte
	var age byte
	var price float64 = 60.0

	fmt.Println("请输入月份:")
	fmt.Scanln(&month)
	fmt.Println("请输入年龄:")
	fmt.Scanln(&age)

	if month >= 4 && month <= 10 {
		if age >= 18 && age <= 60 {
			fmt.Printf("月份是 %v, 年龄是 %v, 票价是 %v", month, age, price)
		} else if age < 18 {
			price = price / 2
			fmt.Printf("月份是 %v, 年龄是 %v, 票价是 %v", month, age, price)
		} else {
			price = price / 3
			fmt.Printf("月份是 %v, 年龄是 %v, 票价是 %v", month, age, price)
		}
	} else {
		if age >= 18 && age <= 60 {
			price = 40
			fmt.Printf("月份是 %v, 年龄是 %v, 票价是 %v", month, age, price)
		} else {
			price = 20
			fmt.Printf("月份是 %v, 年龄是 %v, 票价是 %v", month, age, price)
		}
	}
}

switch分支控制

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

语法

switch 表达式 {
	case 表达式1,表达式2,...:
		语句块1
	case 表达式3,表达式4,...:
		语句块2
	...
	default:
		语句块
}

说明:

• switch的执行流程,先执行表达式,得到值,然后和case的表达式进行比较,如果相等,就匹配到,然后执行对应的case的语句块,然后退出switch
• 如果switch的表达式的值没有和任何的case表达式匹配成功,则执行default的语句块,执行后退出switch
• golang的case后的表达式可以有多个,使用逗号间隔.

func main()  {
	var key byte
	fmt.Println("请输入一个字符: ")
	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("周四")
	case 'f':
		fmt.Println("周五")
	case 'g':
		fmt.Println("周六")
	case 'h':
		fmt.Println("周日")
	default:
		fmt.Println("输入有误...")
	}
}

switch的使用的注意事项

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

package main

import (
	"fmt"
)

func test(char byte) byte  {
	return char + 1
}

func main()  {
	var key byte
	fmt.Println("请输入一个字符: ")
	fmt.Scanf("%c",&key)

	switch test(key) + 1 {
	case 'a':
		fmt.Println("周一")
	case 'b':
		fmt.Println("周二")
	case 'c':
		fmt.Println("周三")
	case 'd':
		fmt.Println("周三")
	case 'e':
		fmt.Println("周四")
	case 'f':
		fmt.Println("周五")
	case 'g':
		fmt.Println("周六")
	case 'h':
		fmt.Println("周日")
	default:
		fmt.Println("输入有误...")
	}
}

• case后的各个表达式的值的数据类型,必须和switch的表达式数据类型一致

• case后面可以带多个表达式,使用逗号间隔

func main()  {
	var n1 int32 = 5
	var n2 int32 = 20

	switch n1 {
	case n2, 10, 5:
		fmt.Println("ok1")
	case 30, 50:
		fmt.Println("ok2")
	default:
		fmt.Println("没有匹配到")
	}
}

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

• 程序匹配到一个case后就会执行对应的代码块,然后退出switch,如果一个都匹配不到,则执行default
• default语句不是必须的
• switch后也可以不带表达式,类似if-else分支来使用

func main()  {
	var age int = 10

	switch  {
	case age == 10:
		fmt.Println("age == ", age)
	case age == 20:
		fmt.Println("age == ", age)
	default:
		fmt.Println("没有匹配到")
	}

	var score int = 90
	switch  {
	case score > 90:
		fmt.Println("优秀")
	case score >= 70 && score <= 90:
		fmt.Println("良好")
	case score >= 60 && score < 70:
		fmt.Println("及格")
	default:
		fmt.Println("不及格")
	}
}

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

• switch穿透-fallthrough,如果在case语句块后增加fallthrough,则会继续执行下一个case,也叫switch穿透

func main()  {
	var num int = 10

	switch num {
	case 10:
		fmt.Println("ok1")
		fallthrough //默认只能穿透一层
	case 20:
		fmt.Println("ok2")
		fallthrough
	case 30:
		fmt.Println("ok3")
	case 40:
		fmt.Println("ok4")
	default:
		fmt.Println("没有匹配到...")
	}
}

运行结果

ok1
ok2
ok3

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

func main()  {
	var x interface{}
	var y = 10.0
	x = y
	switch i := x.(type) {
	case nil:
		fmt.Printf("x的类型 : %T", i)
	case int:
		fmt.Printf("x 是 int 型")
	case float64:
		fmt.Printf("x 是 float64 型")
	case func(int) float64:
		fmt.Printf("x 是func(int) 型")
	case bool, string:
		fmt.Printf("x 是 bool 或 string 型")
	default:
		fmt.Printf("未知型")
	}
}

运行结果

x 是 float64 型

使用switch把小写类型的char型转为大写(键盘输入).只转换a,b,c.其它的输出"other".

func main()  {
	var char byte
	fmt.Println("请输入一个大写字母: ")
	fmt.Scanf("%c", &char)

	switch char {
	case 'a':
		fmt.Println("A")
	case 'b':
		fmt.Println("B")
	case 'c':
		fmt.Println("C")
	default:
		fmt.Println("other")
	}
}

对学生成绩大于60分的,输出"及格".低于60分的,输出"不及格"

func main()  {
	var score byte
	fmt.Println("请输入成绩: ")
	fmt.Scanln(&score)

	switch  {
	case score >= 60:
		fmt.Println("及格")
	case score < 60:
		fmt.Println("不及格")
	default:
		fmt.Println("输入有误...")
	}
}

func main()  {
	var score byte
	fmt.Println("请输入成绩: ")
	fmt.Scanln(&score)

	switch int(score / 60) {
	case 1:
		fmt.Println("及格")
	case 0:
		fmt.Println("不及格")
	default:
		fmt.Println("输入有误...")
	}
}

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

func main()  {
	var month byte
	fmt.Println("请输入月份: ")
	fmt.Scanln(&month)

	switch month {
	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("输入有误...")
	}
}

switch和if的比较

• 如果判断的具体数值不多,而且符合整数,浮点数,字符,字符串这几种类型.建议使用switch语句
• 其它情况: 对区间判断和结果为bool类型的判断,使用if