程序流程控制

在程序中，程序运行的流程控制决定程序是如何执行的，主要有三大流程控制语句:顺序控制,分支控制,循环控制。

一、顺序控制

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

Golang 中定义变量时采用合法的前向引用。

二、分支控制

分支控制就是让程序有选择执行。有三种形式：单分支、双分支、多分支。

1、单分支控制

if 条件表达式{

　　执行代码块

}

当条件表达式为true时，就会执行{}的代码。{}是必须要有的，就算只写一行代码。

package main

import "fmt"

func main() {
	//编写一个程序,可以输入人的年龄,如果该同志的年龄大于 18 岁,则输出 "你年龄大 于 18,要对自己的行为负责!"
	var age int
	fmt.Println("请输入年龄")
	fmt.Scanln(&age)

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

 单分支的流程图:

golang支持在if中直接定义一个变量

package main

import "fmt"

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

 2、双分支控制

if 条件表达式{

　　执行代码块1

}else{

　　执行代码块2

}

当条件表达式成立时，执行代码块1，否则执行代码块2。{}也是必须有的。

package main

import "fmt"

func main() {
	//编写一个程序,输入年龄,如果年龄大于 18 岁,则输出 “你年龄大于18,要对自己的行为负责!”。否则 输出”你的年龄不大这次放过你了”
	var age int
	fmt.Println("请输入年龄:")
	fmt.Scanln(&age)

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

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

package main

import "fmt"

func main() {
	//判断一个年份是否是闰年，闰年的条件是符合下面二者之一:(1)年份能被4整除，但不能被100 整除;(2)能被400整除
	var year int
	fmt.Println("请输入年份")
	fmt.Scanln(&year)

	if (year%4 == 0 && year%100 != 0) || (year%400 == 0) {
		fmt.Println(year, "是闰年")
	}
}

 3、多分支控制

if 条件表达式1{

　　执行代码块1

}else if 条件表达式2{

　　执行代码块2

}else{

　　执行代码块n

}

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

嵌套分支：

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

基本语法：

if 条件表达式{

　　if 条件表达式{

　　　　执行语句1

　　}else{

　　　　执行语句2

　　}

}else{

　　执行语句

}

注意：嵌套分支不宜过多，建议控制在3层内。

4、练习题

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

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...")
	}
}

 (2)、出票系统:根据淡旺季的月份和年龄，打印票价。

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 > 60 {
			fmt.Printf("%v月 票价 %v 年龄 %v ", month, price/3, age)
		} else if age >= 18 {
			fmt.Printf("%v月 票价 %v 年龄 %v ", month, price, age)
		} else {
			fmt.Printf("%v月 票价 %v 年龄 %v ", month, price/2, age)
		}
	} else {
		if age >= 18 && age < 60 {
			fmt.Println("淡季成人票价40")
		} else {
			fmt.Println("淡季儿童和成人票价20")
		}
	}
}

5、switch分支控制 

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

switch 表达式{

　　case 表达式1，表达式2，... :

　　　　语句块1

　　case 表达式3，表达式4，... ：

　　　　语句块2

　　......

　　default :

　　　　语句块

}

switch执行流程:

(1)、先执行表达式得到值，然后和case的表达式进行比较，如果匹配就执行对应的case语句块，然后退出switch控制。
(2)、如果switch的表达式的值没有和任何的case的表达式匹配成功，则执行default的语句块。执行后退出switch的控制。

golang的case后的表达式可以有多个，使用逗号间隔。
golang中的case语句块不需要写break , 因为默认会有,即在默认情况下，当程序执行完case语句块后，就直接退出该switch控制结构。

package main

import "fmt"

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")
		case 'd':
			fmt.Println("D")
		case 'e':
			fmt.Println("E")
		default:
			fmt.Println("other")
	}
}

switch使用的注意事项：
(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分支来使用。

package main

import "fmt"

func main() {
	//switch后也可以不带表达式，类似 if else分支来使用。
	var age int = 10

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

	//case中也可以对范围进行判断
	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("不及格")
	}
}

(8)、switch后也可以直接声明/定义一个变量，分号结束【不推荐】。

package main

import "fmt"

func main() {
	//switch后也可以直接声明/定义一个变量，分号结束【不推荐】
	switch grade := 90; {
		case grade > 90:
			fmt.Println("成绩优秀")
		case grade >= 70 && grade <= 90:
			fmt.Println("成绩良好")
		case grade >= 60 && grade < 70:
			fmt.Println("成绩及格")
		default:
			fmt.Println("不及格")
	}
}

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

package main

import "fmt"

func main() {
	//switch 穿透 fallthrough
	var num int = 10
	switch num {
		case 10:
			fmt.Println("ok")
			fallthrough //默认只能穿透一层
		case 20:
			fmt.Println("ok2")
			fallthrough
		case 30:
			fmt.Println("ok3")
		default:
			fmt.Println("没有匹配到")
	}
}

对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。(注:输入的成绩不能大于100)

package main

import "fmt"

func main() {
	//对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。(注:输入的成绩不能大于100)
	var score float64
	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 冬季

package main

import "fmt"

func main() {
	//根据用户指定月份，打印该月份所属的季节。3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季
	var month byte
	fmt.Println("请输入月份")
	fmt.Scanln(&month)

	switch month {
		case 3, 4, 5:
			fmt.Println("spring")
		case 6, 7, 8:
			fmt.Println("summer")
		case 9, 10, 11:
			fmt.Println("autumn")
		case 12, 1, 2:
			fmt.Println("winter")
		default:
			fmt.Println("输入有误")
	}
}

switch和if的比较:

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

三、循环控制

1、for循环控制

for 循环变量初始化;循环条件;循环变量迭代{

　　循环操作语句

}

for循环的四个要素：

(1)、循环变量初始化

(2)、循环条件

(3)、循环操作语句，也叫循环体

(4)、循环变量迭代

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

for循环流程图：

package main

import "fmt"

func main() {
	for i := 1; i <= 10; i++ {
		fmt.Println("hello world")
	}
}

for循环的第二种使用方式：

for 循环判断条件{

　　循环体

}

package main

import "fmt"

func main() {
	j := 1
	for j <= 10 {
		fmt.Println("golang go", j)
		j++
	}
}

 for循环的第三种使用方式:

for {

　　循环体

}

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

package main

import "fmt"

func main() {
	k := 1
	for {
		if k <= 10 {
			fmt.Println("ok~~", k)
		} else {
			break
		}
		k++
	}
}

 for - range遍历字符串和数组

package main

import "fmt"

func main() {
	//字符串遍历方式1
	var str string = "hello,world"
	for i := 0; i < len(str); i++ {
		fmt.Printf("%c \t", str[i])
	}
	fmt.Println()

	//字符串遍历方式2 for - range
	str = "abcdef"
	for index, val := range str {
		fmt.Printf("index = %d val = %c\n", index, val)
	}
}

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

package main

import "fmt"

func main() {
	//[]rune切片方式遍历有中文的字符串
	var str string = "hello,world北京"
	str2 := []rune(str)
	for i := 0; i < len(str2); i++ {
		fmt.Printf("%c \t", str2[i])
	}
	fmt.Println()

	//for - range 方式遍历有中文的字符串
	str = "abdedf上海"
	for index, val := range str {
		fmt.Printf("index = %d val = %c\n", index, val)
	}
}

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

package main

import "fmt"

func main() {
	//打印1~100之间所有是9的倍数的整数的个数及总和
	var max uint64 = 100
	var count uint64 = 0
	var sum uint64 = 0
	var i uint64 = 1
	for ; i <= max; i++ {
		if i%9 == 0 {
			count++
			sum += i
		}
	}
	fmt.Printf("count = %v sum = %v\n", count, sum)
}

 2、while循环和do while循环

golang语言中没有while和do while循环。

如果需要使用while循环和do while循环类似的循环，可以通过for循环来实现其使用效果。

(1)、while循环的实现：

循环变量初始化

for{

　　if 循环条件表达式{

　　　　break  //跳出for循环

　　}

　　循环体

　　循环变量迭代

}

package main

import "fmt"

func main() {
	var i int = 1
	for {
		if i > 10 {
			break
		}
		fmt.Println("hello,world", i)
		i++
	}
	fmt.Println("i = ", i)
}

 (2)、do while循环的实现：

循环变量初始化

for{

　　循环体

　　循环变量迭代

　　if 循环条件表达式{

　　　　break  //跳出for循环

　　}

}

package main

import "fmt"

func main() {
	var j int = 1
	for {
		fmt.Println("ok ", j)
		j++
		if j > 10 {
			break
		}
	}
	fmt.Println("j = ", j)
}

 3、多重循环控制

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

统计3个班成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分[学生的成 绩从键盘输入]

package main

import "fmt"

func main() {
	//统计3个班成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分[学生的成 绩从键盘输入]
	var classNum int = 2
	var stuNum int = 5
	var totalSum float64 = 0.0

	for i := 1; i <= classNum; i++ {
		sum := 0.0
		for j := 1; j <= stuNum; j++ {
			var score float64
			fmt.Printf("请输入第%d班 第%d个学生的成绩\n", i, j)
			fmt.Scanln(&score)
			sum += score
		}
		fmt.Printf("第%d个班级的平均分是%v\n", i, sum/float64(stuNum))
		totalSum += sum
	}
	fmt.Printf("各个班级的总成绩%v，所有班级平均分是%v\n", totalSum, totalSum/float64(stuNum*classNum))
}

 4、练习题

(1)、打印一个矩形

package main

import "fmt"

func main() {
	for i := 1; i <= 3; i++ {
		for j := 1; j <= 3; j++ {
			fmt.Print("* ")
		}
		fmt.Println()
	}
}

(2)、打印半个金字塔

package main

import "fmt"

func main() {
	for i := 1; i <= 3; i++ {
		for j := 1; j <= i; j++ {
			fmt.Print("* ")
		}
		fmt.Println()
	}
}

(3)、打印整个金字塔

package main

import "fmt"

func main() {
	tower(5)
	fmt.Println()
	tower2(5)
}

func tower(level int) {
	for i := 1; i <= level; i++ {
		for j := 1; j <= level-i; j++ {
			fmt.Print("  ")
		}
		for n := 1; n < i; n++ {
			fmt.Print("* ")
		}
		for k := 1; k <= i; k++ {
			fmt.Print("* ")
		}
		fmt.Println()
	}
}

func tower2(level int) {
	for i := 1; i <= level; i++ {
		for j := 1; j <= level-i; j++ {
			fmt.Print("  ")
		}
		for k := 1; k <= 2*i-1; k++ {
			fmt.Print("* ")
		}
		fmt.Println()
	}
}

(4)、打印空心金字塔

package main

import "fmt"

func main() {
	tower(9)
}

func tower(level int) {
	for i := 1; i <= level; i++ {
		for j := 1; j <= level-i; j++ {
			fmt.Print("  ")
		}
		for k := 1; k <= 2*i-1; k++ {
			if k == 1 || k == 2*i-1 || i == level {
				fmt.Print("* ")
			} else {
				fmt.Print("  ")
			}
		}
		fmt.Println()
	}
}

(5)、打印九九乘法表

package main

import "fmt"

func main() {
	//打印九九乘法表
	var num int = 9
	for i := 1; i <= num; i++ {
		for j := 1; j <= i; j++ {
			fmt.Printf("%v * %v = %v \t", j, i, j*i)
		}
		fmt.Println()
	}
}

 四、跳转控制语句

1、break

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

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {
	var count int = 0
	//time.Now().Unix()返回一个从1970:01:01的0时0分0秒到现在的秒数

	for {
		rand.Seed(time.Now().UnixNano()) //在go中生成随机数需要一个种子，否则返回的值总是固定的。
		n := rand.Intn(100) + 1          //[0 100)
		fmt.Println("n = ", n)
		count++
		if (n == 9) {
			break
		}
	}
	fmt.Println("生成99一共使用了", count, "次")
}

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

break的注意事项和使用细节:
break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块。

package main

import "fmt"

func main() {
	lable2:
		for i := 0; i < 4; i++ {
		//lable1:
			for j := 0; j < 10; j++ {
				if j == 2 {
					break lable2
				}
				fmt.Println("j = ", j)
			}
		}
}

 练习题：100以内的数求和，求出当和第一次大于20的当前数

package main

import "fmt"

func main() {
	//100以内的数求和，求出当和第一次大于20的当前数
	sum := 0
	for i := 1; i <= 100; i++ {
		sum += i
		if sum > 20 {
			fmt.Println("当sum>20时，当前数是", i)
			break
		}
	}
}

2、continue

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

package main

import "fmt"

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

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

package main

import "fmt"

func main() {
	//打印1——100之内的奇数[要求使用for循环+continue]
	for i := 1; i <= 100; i++ {
		if i%2 == 0 {
			continue
		}
		fmt.Println("奇数是", i)
	}
}

 从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序

package main

import "fmt"

func main() {
	//从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序
	var positiveCount int
	var negativeCount int
	var num int

	for {
		fmt.Println("请输入一个整数")
		fmt.Scanln(&num)

		if num == 0 {
			break
		}

		if num > 0 {
			positiveCount++
			continue
		}
		negativeCount++
	}
	fmt.Printf("正数有%v个，负数有%v个\n", positiveCount, negativeCount)
}

 3、goto

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

package main

import "fmt"

func main() {
	var n int = 30

	fmt.Println("ok")

	if n > 20 {
		goto lable1
	}

	fmt.Println("ok1")
	fmt.Println("ok2")
	fmt.Println("ok3")
	lable1:
	fmt.Println("ok4")
	fmt.Println("ok5")
}

 4、return

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

package main

import "fmt"

func main() {
	for i := 1; i <= 10; i++ {
		if i == 3 {
			return
		}
		fmt.Println("i = ", i)
	}
	fmt.Println("hello world")
}