golang（4）流程控制

1.顺序控制
2.分支控制
3.循环控制

分支控制

》单分支，双分支，多分支

单分支

if 条件 {
	执行代码
}

编写一个程序，判断输入年龄是否大于18，如果大于输出一句话

package main

import "fmt"

func main()  {

	var age int
	fmt.Println("请输入年龄")
	fmt.Scanln(&age)
	if age > 18 {
		println("你已经过了18岁")
	}
}

C:\Users\g\go\src\awesomeProject>go run 1.go
请输入年龄
25

双分支

if 条件{
	执行1
} else{
	执行2	
}

判断输入年龄是否大于18，如果大于输出一句话，小于输出一句话

package main

import "fmt"

func main()  {

	var age int
	fmt.Println("请输入年龄")
	fmt.Scanln(&age)
	if age > 18 {
		println("你已经过了18岁")
	}else {
		println("你还小")
	}
}

C:\Users\g\go\src\awesomeProject>go run 1.go
请输入年龄
19
你已经过了18岁

C:\Users\g\go\src\awesomeProject>go run 1.go
请输入年龄
11
你还小

双分支中执行的时候只能执行其中一个 执行了if就不会执行else

多分支

if 条件{
	执行1
}else if 条件{
	执行2
}
.....
else{
	执行n
}

嵌套分支

在if中又嵌套一个if
在嵌套分支中建议控制在三层内

switch分支

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

}

package main

import "fmt"

func main()  {

	var input byte
	fmt.Println("请输入a-g任意字符")
	fmt.Scanf("%c",&input)
	switch input {
		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("周天")
		default:
			fmt.Println("error")

	}
}

C:\Users\g\go\src\awesomeProject>go run 1.go
请输入a-g任意字符
a
周一

C:\Users\g\go\src\awesomeProject>go run 1.go
请输入a-g任意字符
b
周二

for循环

for循环语法

for循环变脸初始化；循环条件；循环变量迭代{
	循环操作
}

package main

import "fmt"

func main()  {

	for i := 1;i <= 10; i++{
//for 设置i的初始值；判断是否小于10，下来自加1
		fmt.Println("hello world")
	}
}

for循环的使用细节
1.循环条件返回为一个布尔值
2.for循环的第二种返回方式

for 循环判断条件{
	循环执行语句
}
//将变量初始化和变量迭代写道其他位置

j := 1
for j <= 10 {
	fmt.Println("hello world")
	j++  //迭代
}

3.for的死循环

for{
	执行语句
}

等价于
for ； ； {} 都是一个无限循环 通常需要配合break

4.遍历字符串
1）

str := "hellow,world"
for i:=0;i < len(str); i++{
	fmt.Printf("%c \n",str[i]) //提取下标
}

2） for-range方法

str = "qweasd-1"
for index,val := range str{  //将str的下标值和字符分别赋给index和val
	fmt.Printf("index=%d,val=%c \n",index,val)
}

3）while 和do … while的实现

Go语言中没有while循环，但是可以通过for实现效果
while
循环变量初始化

for {
	if条件{
	break
	}
	循环语句
	迭代
}

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

4）do…while
循环变量初始化

for {
	循环语句
	循环变量迭代
	if 循环条件{
	break
	}
}

多重循环控制

1.将一个循环放在另一个循环体内，就形成了嵌套循环。外面得到for称为外层循环里面的for称为内层循环。（一般不要超过三层）
2.嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环。才能节水外层的当此循环开始下次循环。
3.外层循环为m次，内层循环为n次，整个循环为m*n次

例：输入几个班学生的成绩，分别算出每个班的平均分和全部的平均分

1.首先算平均分

sum := 0.0  //总分
for i := 1; i <= 5; i++ {   //5个学生
	var score float64
	fmt.Printf("请输入%d个学生的成绩 \n", i)  //输入成绩
	fmt.Scanln(&score)
	sum += score
}

fmt.Printf("%v班级的平均分为%v \n",j, sum/5)  //算出平均分

2.多来几个班

for j := 1 ; j <= 3;j++ {  //三个班级  用for循环
	sum := 0.0
	

再将班级和人数写成变量更为灵活

package main

import "fmt"

func main()  {
	var classNum int= 3  //班级个数
	var stuNum int = 5  //学生人数均可修改

	var totalSum float64 = 0.0
	for j := 1 ; j <= classNum;j++ {
		sum := 0.0
		for i := 1; i <= stuNum; i++ {
			var score float64
			fmt.Printf("请输入%d个学生的成绩 \n", i)
			fmt.Scanln(&score)
			sum += score

		}

		fmt.Printf("%v班级的平均分为%v \n",j, sum/float64(stuNum))
		totalSum += sum
	}
	fmt.Printf("所有班级的平均分为%v \n", totalSum/float64(stuNum*classNum))
}

break的应用

随机生成数字，直到生成99这个数字后停止

首先生成随机数字

n := rand.Intn(100) + 1 //生成的本身是从0到99  想生成1-100需要加1
fmt.Println(n)  //输出始终为82

下面需要再引入包time

rand.Seed(time.Now().Unix()) //返回1970年1月1日到现在的秒数

这样随机数才会变

package main

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

func main()  {

	//生成随机整数
	var num int = 0
	for {
		rand.Seed(time.Now().Unix())
		n := rand.Intn(100) + 1
		fmt.Println("n=",n)
		num ++
		if n == 99{
			break
		}
	}
	fmt.Printf("生成99用了%d次" ,num)
}
 //生成99用了1478411次
unix的模块单位为秒  太慢  我们可以将时间改为纳秒
rand.Seed(time.Now().UnixNano())

//生成99用了2033次
这样就会快很多