第5章 程序流程控制

最新推荐文章于 2024-07-30 06:13:10 发布
最新推荐文章于 2024-07-30 06:13:10 发布
阅读量380 收藏 2
点赞数
分类专栏： Go语言学习笔记 文章标签： golang go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45403184/article/details/128931394
版权

5.1程序流程控制介绍

在程序中，程序运行的流程控制决定程序是如何执行的，是必须掌握的，主要右三大流程控制语句。
1.顺序控制
2.分支控制
3.循环控制

5.2顺序控制

程序从上到下逐行地执行，中间没有任何判断和跳转
在下面的代码中，没有判断，也没有跳转，因此程序按照默认的流程执行，即顺序控制。

package main

import "fmt"

func main() {
	//5.2 顺序控制，没有判断，也没有跳转，因此程序按照默认的流程执行，即顺序控制。
	a := 11
	b := 22

	fmt.Println(a)
	fmt.Println(b)
	c := 111
	fmt.Println(c)
}

image.png

5.2.1顺序控制的一个流程图

image.png

5.2.2 顺序控制举例和注意事项

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

package main

import "fmt"

func main1() {
	var num1 int = 10
	var num2 int = num1 + 20
	fmt.Println(num2)
}
func main() {
	var num2 int = num1 + 20 //使用了num1，但在这之前没有声明num1，故无法找的num1
	var num1 int = 10        //应该使用num1之前声明
	fmt.Println(num2)
}

image.png

5.3 分支控制

5.3.1 分支控制的基本介绍

分支控制就是让程序有选择执行。有下面三种形式
1.单分支
2.双分支
3.多分支

5.3.2 单分支控制

基本语法
if 条件表达式{
执行代码
}
说明：当条件表达式位true时，就会执行{}的代码。
应用案例请大家看个案例[ifDemo.go]:编写一个程序,可以输入人的年龄,如果该同志的年龄大于18岁,则输出"你年龄大于18,要对自己的行为负责!"需求—[分析]---->代码代码:输出的结果：

func main() {
	var age int

	fmt.Println("请输入年龄：")
	fmt.Scanln(&age)
	if age > 18 {
		fmt.Println("你的年龄大于18，要对自己的行为负责")

	}
 
}

image.png

5.3.3 双分支控制

基本语法
image.png

func main() {
	var age int

	fmt.Println("请输入年龄：")
	fmt.Scanln(&age)
	if age > 18 {
		fmt.Println("你的年龄大于18")
	} else {
		fmt.Println("你的年龄不允许访问")
	}

}

image.pngimage.png
对双分支的总结
1.从上图看条件表达式就是age>18
2.执行代码块1===>fmt.Println(“你的年龄大于18”)…
3.执行代码块2===>fmt.Println(“你的年龄不大…”).
4.强调一下双分支只会执行其中的一个分支。

5.3.4 案例

func main() {
	var x int = 4
	var y int = 1
	if x > 2 {
		if y > 1 {
			fmt.Println(x + y)

		}
		fmt.Println("atguigu")

	} else {
		fmt.Printf("x = %v", x)
	}

	//5)编写程序，声明2个int32型变量并赋值。判断两数之和，如果大于等于50，打印“helloworld!”
	var a int32 = 24
	var b int32 = 32
	if a+b >= 50 {
		fmt.Println("HeloWorld!")
	}

	//6)编写程序，声明2个float64型变量并赋值。判断第一个数大于10.0，且第2个数小于20.0，打印两数之和。
	var c float64 = 21.1
	var d float64 = 11.22

	if c > 10.0 && d < 20.0 {
		fmt.Println(c + d)

	}
	//7)【选作】定义两个变量int32，判断二者的和，是否能被3又能被5整除，打印提示信息

	var n1 int32 = 10
	var n2 int32 = 5
	if (n1+n2)%3 == 0 && (n1+n2)%5 == 0 {
		fmt.Println("可以被3和5同时整除")
	}
	//8)判断一个年份是否是闰年，闰年的条件是符合下面二者之一：(1)年份能被4整除，但不能被100整除；(2)能被400整除

	var year int
	fmt.Println("输入年份:")
	fmt.Scanln(&year)

	if (year%4 == 0 && year%100 != 0) || year%400 == 0 {

	}

}

5.3.5 多分支控制

基本语法
if 条件表达式1{
执行代码快1
}else if 条件表达式2{
执行代码快2
}
……
else {
执行代码块n
}
对上面的基本语法的说明
1）多分支的判断流程如下：
1.先判断条件表达式1是否成立，如果为真，就执行代码快1
2.如果条件表达式1如果为假，就去判断条件表达式2 是否成立，如果条件表达式2为真，就执行代码块2
3.以此类推
4.如果所有的条件表达式不成立，则执行else的语句块
2）else不是必须的
3）多分支只能有一个执行入口
分支流程图
image.png
image.png

func main() {
	var chengji float32
	fmt.Println("请输入岳小鹏的分数：")
	fmt.Scanln(&chengji)
	if chengji == 100 {
		fmt.Println("奖励BMW")
	} else if 80 < chengji && chengji <= 99 {
		fmt.Println("奖励手机")
	} else if 60 <= chengji && chengji <= 80 {
		fmt.Println("奖励平板")
	} else {
		fmt.Println("下次努力")
	}
}

image.png
image.png
image.png

func main() {

	//案例3求平方根
	var a float64 = 2.0
	var b float64 = 4.0
	var c float64 = 2.0

	m := b*b - 4*a*c
	if (b*b - 4*a*c) > 0 {
		//有两个解
		x1 := (-b + math.Sqrt(m)) / (2 * a)
		x2 := (-b - math.Sqrt(m)) / (2 * a)

		fmt.Printf("方程的根为：%v和%v", x1, x2)

	} else if (b*b - 4*a*c) == 0 {
		//有一个解
		x1 := (-b + math.Sqrt(m)) / (2 * a)
		fmt.Printf("方程的根为：%v", x1)
	} else {
		//(b*b-4*a*c)<0
		//无解
	}
}

image.png
image.png

func main() {
	//案例4
	var height int32
	var money float32
	var handsome bool
	fmt.Println("请输入的你的身高(厘米)，财富(万)，是否帅(true/false)，使用空格隔开")
	fmt.Scanf("%v %b %v", &height, &money, &handsome)
	fmt.Println(height, money, handsome)

	if height > 180 && money > 1000 && handsome {
		fmt.Println("非嫁不可")

	} else if height > 180 || money > 1000 || handsome {
		fmt.Println("嫁吧")

	} else {
		fmt.Println("不嫁")
	}

}

image.png

5.3.6 嵌套分支

1.基本介绍
在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分支结构，外面的称为外层分支
2.基本语法
image.png
说明：嵌套分支不宜过多，在3层内。

应用案例1

参加百米运动会，如果用时8秒以内进入决赛，否则提示淘汰。并且根据性别提示进入男子组或女子组。【可以让学员先练习下】,输入成绩和性别。
代码:

func main() {
	//应用案例1

	var score float32
	var gender string
	fmt.Println("请输入秒数：")
	fmt.Scanln(&score)

	if score < 8 {
		fmt.Println("请输输入性别：")
		fmt.Scanln(&gender)
		if gender == "男" {
			fmt.Println("恭喜，进入男子组")

		} else if gender == "女" {
			fmt.Println("恭喜，进入女子组")
		} else {
			fmt.Println("输入错误")
		}

	} else {
		fmt.Println("少年，下次来战！")
	}

}

image.png

应用案例2

出票系统：根据淡旺季的月份和年龄，打印票价[考虑学生先做]
4_10旺季：
成人（18-60）：
60儿童（<18）:
半价老人（>60）:
1/3淡季：
成人：40
其他：20
代码：

func main() {
	//应该案例2
	//获取当前月份
	var month int
	fmt.Println("请输入当前月份：")
	fmt.Scanln(&month)
	var age int
	fmt.Println("请输入年龄：")
	fmt.Scanln(&age)

	if month > 4 && month < 10 {
		if age >= 18 && age <= 60 {
			fmt.Printf("当前为%v月，您的年龄为：%v，请购买成人票，价格为60元", month, age)
		} else if age < 18 {
			fmt.Printf("当前为%v月，您的年龄为：%v，请购买儿童票，价格为30元", month, age)

		} else if age > 60 {
			fmt.Printf("当前为%v月，您的年龄为：%v，请购买老人票，价格为20元", month, age)

		} else {
			fmt.Println("输入错误")
		}

	} else {
		if age >= 18 && age <= 60 {
			fmt.Printf("当前为%v月，您的年龄为：%v，请购买成人票，价格为40元", month, age)

		} else {
			fmt.Printf("当前为%v月，您的年龄为：%v，请购买其它票，价格为20元", month, age)
		}

	}

}

image.png

5.4 Switch分支控制

5.4.1 基本的介绍

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

5.4.2基本语法

image.png

5.4.3switch的流程图

image.png
对上图的说明和总结
1)switch的执行的流程是，先执行表达式，得到值，然后和case的表达式进行比较，如果相等，就匹配到，然后执行对应的case的语句块，然后退出switch控制。
2)如果switch的表达式的值没有和任何的case的表达式匹配成功，则执行default的语句块。执行后退出switch的控制.
3)golang的case后的表达式可以有多个，使用逗号间隔.
4)golang中的case语句块不需要写break,因为默认会有,即在默认情况下，当程序执行完case语句块后，就直接退出该switch控制结构。

5.4.4switch快速入门案例案例：

请编写一个程序，该程序可以接收一个字符，比如:a,b,c,d,e,f,ga表示星期一，b表示星期二…根据用户的输入显示相依的信息.要求使用switch语句完成
代码：
5.4.5switch的使用的注意事项和细节
1)case/switch后是一个表达式(即：常量值、变量、一个有返回值的函数等都可以)

func main() {
	var week byte
	fmt.Println("请输入a,b,c,d,e,f,g中任一一个字符:")
	fmt.Scanln(&week)

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

}

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

func main543() {
	var week byte
	fmt.Println("请输入a,b,c,d,e,f,g中任一一个字符:")
	fmt.Scanln(&week)

	switch test(week) + 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("星期天")
	default:
		fmt.Println("输入有误")
	}

}

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

func main() {
	//2)cas后的各个表达式的值的数据类型，必须和switch的表达式数据类型一致
	var n1 int32 = 20
	var n2 int64 = 20
	switch n1 {
	case n2:
		fmt.Println("ok1")
	default:
		fmt.Println(n2)
	}

}

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

var n3 int32 = 5
	var n4 int32 = 20
	switch n3 {
	case n3, 10, 5: //只要存在一个，为true
		fmt.Println("ok2")
	default:
		fmt.Println("没有匹配到", n4)
	}

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

    var n5 int32 = 5
    var n6 int32 = 20
    switch n1 {
    case n5, 10, 5: //case后面可以有多个表达式
        fmt.Println("ok3")
    case 5: //报错，在前面已经有常量5，因此重复，会报错
        fmt.Println("ok4")
    default:
        fmt.Println(n6)
    }

5）case后面不需要带break，程序匹配到一个case后就会执行对应的代码块，然后退出switch，如果一个都匹配不到，则执行default
6）default语句不是必须的
7）switch后也可以不带表达式，类似if–else分支来使用
案例演示：

//switch 后也可以不带表达式，类似if --else分支来使用
	var age int = 10
	switch {
	case age == 10:
		fmt.Println("age ==10")
	case age == 20:
		fmt.Println("age ==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("不及格")
	}

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

switch grade := 90; { //在golang中，可以这样写
	case grade > 90:
		fmt.Println("成绩优秀")
	case grade >= 70 && grade <= 90:
		fmt.Println("成绩优良")
	case grade >= 60 && grade < 70:
		fmt.Println("成绩及格")
	default:
		fmt.Println("不及格")

	}

image.png
9）switch 穿透-fallthrough，如果在case语句块增加fallthrough，则会继续执行下一个case，也叫switch穿透

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

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

//10）Type Switch：Switch语句还可以被用于type-switch来判断某个interface变量中实际指向的变量类型
    var x interface{}
    var y = 10.0


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


    }

image.png

5.4.6 switch练习

1)使用switch把小写类型的char型转为大写（键盘输入）。只转换a，b，c，d，e，其它的输出“other”

//1)转换大小写
	var char byte
	fmt.Println("请输入a,b,c,d,e其中一个字母：")
	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")
	}

image.png

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

		var score int
		fmt.Println("请输入分数：")
		fmt.Scanln(&score)
		switch {
		case score <= 100 && score >= 60:
			fmt.Println("合格")
		case score < 60:
			fmt.Println("不合格")
		default:
			fmt.Println("输入错误")

		}
		var score float64
		fmt.Println("成绩：")
		fmt.Scanln(&score)
		x := int(score / 60)
		switch x {
		case 1:
			fmt.Println("及格")
		case 0:
			fmt.Println("不及格")
		default:
			fmt.Println("错误")
		}

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

var season int
	fmt.Println("输入月份:")
	fmt.Scanln(&season)
	switch season {
	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("输入错误")

	}

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

5.5for循环控制

5.5.1基本介绍

听其名而知其意。就是让我们的一段代码循环的执行。

5.5.2一个实际的需求

编写一个程序,可以打印10句

5.5.3 for循环的基本语句

语法格式：
for 循环变量初始化；循环条件；循环变量迭代{
循环操作(语句)
}
对上面的语法格式说明
1）对for循环来说，有四个要素：
2）循环变量初始化
3）循环条件
4）循环变量迭代
for循环执行的顺序说明：
1）执行循环变量初始化，比如i:=1
2）执行循环条件，比如i<=10
3）如果循环条件为真，就执行循环操作：比如fmt.Println(“…”)
4）反复执行2，3，4步骤，直到循环条件为False，就退出for循环。

5.5.4 for循环执行流程分析

for循环的流程图
image.png

5.5.5 for循环的使用注意事项和细节讨论

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

2）for循环的第二种使用方式

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

//5.5.5
    j := 1        //循环变量初始化
    for j <= 10 { //循环条件
        fmt.Println("合理", j)
        j++


    }

image.png

3)for循环的第三种使用方式

for{
//循环执行语句
}

	k := 1
	for { //这里也等价for;;{
		if k <= 10 {
			fmt.Println("ok~~", k)

		} else {
			break //跳出循环
		}
		k++
	}

image.png
4) Golang提供for-range的方式，可以方便遍历字符串和数组
遍历字符串
方式1：

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


    }

image.png
方式2-for-range

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

image.png
若字符串包含中文，那么传统的遍历字符串方式，就是错误，会出现乱码。原因是传统的字符串的遍历是按照字节来遍历，而一个汉字在utf-8编码是对于3个字节
如何解决，需要将str转成 []rune 切片=>体验一把

fmt.Println(){
	//字符串遍历方式1-传统方式
	var str1 string = "hello,world!北京"
	str2 := []rune(str1) //就是把str转成[]rune
	for i := 0; i < len(str2); i++ {
		fmt.Printf("%c\n", str2[i])

	}
	//对应for-range遍历方式而言，是按照字符方式遍历。因此如果字符串有中文，也是可以的
	//字符串遍历方式2-for-range
	var sta3 string = "abcd~上海"
	for index2, val2 := range sta3 {
		fmt.Printf("index2=%d,val2=%c\n", index2, val2)
	}

}

image.png

5.5.6for循环的课堂练习

1)打印1~100之间所有是9的倍数的整数的个数及总和
func main() {
	//5.5.6 联系题
	//1)打印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 {
			fmt.Println(i) //打印符合要求的数
			count++        //符合要求的个数
			sum += i       //将符合要求的数相加
		}

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

image.png

2)完成下面的表达式输出，6是可变的

image.png

	//2)完成下面的表达式输出，6是可变的
	var n int = 6
	for i := 0; i < n; i++ {
		fmt.Printf("%v+%v=%v\n", i, n-i, n)
	}
}

image.png

5.6 while 和do…while的实现

Go语言没有whiile和do…while语法，这一点需要注意，若使用，可以通过for循环来实现其使用效果

5.6.1 while 循环的实现
循环变量初始化
for{
    if 循环条件表达式{     //这里是控制条件
        break //跳出for循环
        }
    循环操作(语句)
    循环变量迭代
    }

说明：
1）for循环时一个无限循环
2）break语句就是跳出for循环
使用while循环方式输出10句“你好”

func main() {
	//5.6.1 while循环
	//1）使用while循环方式输出10句“你好”

	var i int = 1
	for {
		if i > 10 {
			break
		}
		fmt.Printf("你好+%v\n", i)
		i++

	}
	fmt.Println(i)

}

image.png

5.6.2do…while的实现
循环变量初始化
for{
    循环操作(语句)
    循环变量迭代
    if循环条件表达式{
      break //跳出for循环  
    }
}

说明：
1）上面的循环是先执行，再判断，因此至少执行一次。
2）当循环条件成立后，就会执行break，break就是跳出for循环，结束循环。

5.7 多重循环控制(重点，难点)

5.7.1基本介绍

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

5.7.2应用案例

1)统计3个班成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]
编程时两大绝招:
(1)先易后难，即将一个复杂的问题分解成简单的问题。
(2)先死后活代码:

func main() {
	//5.7 嵌套循环
	//5.7.2 实例
	var ClassNum int = 2
	var StNum int = 3
	var totalSum float64 = 0.0

	for j := 1; j <= ClassNum; j++ {
		sum := 0.0
		var passCount = 0 //放在这里，当一个班级输入结束后，下一个班级重新赋值为0
		fmt.Println("*****")
		for i := 1; i <= StNum; i++ {
			var score float64
			fmt.Printf("请输入%d班，第%d个学生的成绩", j, i)
			fmt.Scanln(&score)
			//累计总分
			sum += score

			//统计每个班级的及格人数
			if score >= 60 {
				passCount++
			}

		}
		fmt.Printf("%d班的平均分分为%v\n", j, sum/float64(StNum))
		fmt.Printf("%d班及格人数为%v\n", j, passCount) //这个值有问题
		totalSum += sum
	}
	fmt.Printf("各个班级总成绩%v，所有班级的平均分%v", totalSum, totalSum/float64(StNum*2))
}

image.png
3)打印金字塔

func main() {
	//5.7.2
	// 3)打印经典金字塔案例
	//先死后活，定义层数
	//打印半边金字塔
	var totalLevel int = 3
	//i 表示层数
	for i := 0; i < totalLevel; i++ {
		//打印一个矩形

		//打印每层个数
		for k := 1; k <= i; k++ { //第一次传过来的i值是0，k>0,所以第一次不执行
			fmt.Printf("#")
		}
		fmt.Println("*")
	}

}

image.png
3)打印金字塔

func main5723() {
	//5.7.2
	// 3)打印经典金字塔案例
	/*

			 *
			***
		   *****

	*/

	//先死后活，定义层数
	//打印半边金字塔
	var totalLevel int = 5
	//i 表示层数
	for i := 1; i <= totalLevel; i++ {
		fmt.Println() //换行的作用

		//打印空格
		for k := 1; k <= totalLevel-i; k++ {
			fmt.Print("&") //这里可以换成空格
		}

		//打印每层个数
		for j := 1; j <= i*2-1; j++ {
			//下面的判断作用是金字塔中间是否是空格或其它内容
			// if j == 1 || j == 2*i-1 || i == totalLevel {
			// 	fmt.Print("#")
			// } else {
			// 	fmt.Print(" ")
			// }
			fmt.Print("*")
		}

	}

}

image.png
4）打印九九乘法表

func main() {
	//3)打印九九乘法表
	//设定层数
	var piles int = 9

	for i := 1; i <= piles; i++ {
		fmt.Println("")
		//打印每一层
		for k := 1; k <= i; k++ {
			fmt.Printf("%vx%v=%v ", k, i, i*k)

		}

	}

}

image.png

个人总结：

多重循环重点在于每层循环的作用。第一层循环控制层数，第二层控制每层内容

5.8 跳转控制语句-break

5.8.1看一个具体需求，引出break

image.png

5.8.2 案例

随机生成1-100的一个数，直到生成了99这个数。
分析，编写一个无限循环的控制，然后不停的随机生成数，当生成了99时，就退出这个无限循环
–>break 提示使用

func main() {
	//5.8.1
	//在go中，需要生成一个随机额种子，否则返回的值总是固定的。
	//time.Now().Unix():返回一个从1970-1-1 0:0:0 到现在的一个秒数
	// rand.Seed(time.Now().Unix())
	// fmt.Println("n", rand.Intn(100)+1)

	var count int = 0

	for {
		rand.Seed(time.Now().UnixMicro())
		n := rand.Intn(100) + 1
		fmt.Println("n=", n)
		count++
		if n == 99 {
			break
		}

	}
	fmt.Println("生成99一共用了", count)

}

image.png

5.8.3 基本介绍

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

5.8.4 基本语法：

{
……
brek
……
}

5.8.5 以for循环使用break为列，画出示意图

image.png

5.8.6 break的注意事项和使用细节

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

func main() {
	//5.8.6
	//这里演示一个指定标签的形式来使用break
lable2:
	for i := 0; i < 4; i++ {
		fmt.Println("*********")
		//lable1://设置一个标签
		for j := 0; j < 10; j++ {
			if j == 2 {
				break lable2 //
			}
			fmt.Println("j=", j)

		}

	}
}

image.png
3）对上面案例的说明
（1）break默认会跳出最近的for循环
（2）break后面可以指定标签，跳出标签对应的for循环

5.8.7 案列

这个案例不完美。无法再输入错误后继续执行

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

		}

	}
	//2）实现登录验证，有三次机会，如果用户名为“张无忌”,密码“888”，提示登录成功，否则提示还有几次机会

	var Name string
	var Password string
	fmt.Println("请输入用户：")
	fmt.Scanln(&Name)
	fmt.Println("请输入密码：")
	fmt.Scanln(&Password)

	var next int = 3
	for i := 1; i <= 3; i++ {

		if Name == "张无忌" && Password == "888" {
			fmt.Println("登录成功！")
			break
		} else {
			next--
			fmt.Printf("登录信息错误，剩余%v次机会\n", next)
		}
		if next == 0 {
			fmt.Println("机会用完")

		}
	}
}

5.9 跳转控制语句-continue

5.9.1 基本介绍：

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

5.9.2 基本语法

{
	……
    continue
    ……
}

5.9.3 continue流程图

image.png

5.9.4 案例分析

func main() {
	//5.9 continue的使用
	for i := 0; i < 4; i++ {
		//
		for j := 0; j < 10; j++ {
			if j == 2 {
				continue

			}
			fmt.Println("j=", j)

		}

	}

}

image.png

5.9.5 案例

1）练习题
func main() {
	//5.9.5continu 的课堂练习
	//练习1
	//1）
	for i := 0; i < 13; i++ {
		if i == 10 {
			continue

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

		}

	}
	//3)
	fmt.Println("----------------")
here:
	for i := 0; i < 2; i++ {
		for j := 1; j < 4; j++ {
			if j == 2 {
				continue here
			}
			fmt.Println("i=", i, "j=", j)
		}
	}

}

image.png

2）continue实现打印1—100之内的奇数【要求使用for循环+continue】
func main() {
	//5.9.5-2
	//2）continue实现打印1---100之内的奇数【要求使用for循环+continue】

	for i := 1; i <= 100; i++ {
		if i%2 == 0 {
			continue

		}
		fmt.Println("奇数为：", i)

	}

}

image.png

3）从键盘输入个数不确定的整数，平判断读入的正整数和负数的个数，输入为0时结束程序
func main() {
	//5.9.5-3
	//3）
	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", positiveCount, negativeCount)
}

image.png

5.9.6 练习题2

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

func main() {
	//5.9.5-3)
	//3)练习题
	var RMB float32 = 100000  //所持RMB
	var next int

	for {

		if RMB > 50000 {

			next++
			RMB = RMB - RMB*0.05
			fmt.Printf("所持RMB大于50000，每通过一次扣持有RMB的0.05，通过第%v次路口，当前剩余RMB为：%v\n", next, RMB)
		}

		if RMB <= 50000 {
			next++
			RMB = RMB - 1000
			fmt.Printf("所持RMB小于50000，每通过一次扣1000RMB,通过第%v次路口，当前剩余RMB为：%v\n", next, RMB)

		}
		if RMB <= 1000 {
			break

		}

	}
	fmt.Println("此人可以通过", next)

}

image.png

5.10 跳转控制语句-goto

5.10.1 goto基本介绍

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

5.10.2 goto基本语法

goto lable
……
lable:statement

5.10.3 goto的流程图

image.png

5.10.4 案例

func main() {
	//5.10 goto
	//入门案例
	var n int = 30
	//演示goto的使用
	fmt.Println("ok1")
	if n > 20 {
		goto lable1

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

image.png

5.11 跳转控制语句-return

5.11.1 介绍：

return使用在方法或函数中，表示跳出所在方法或函数，在讲解函数的时候，详细的介绍

func main() {
	for i := 1; i <= 10; i++ {
		if i == 3 {
			return

		}
		fmt.Println("哇哇", i)
	}
	fmt.Println("Hello World!")
}

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

闪耀的Cat
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Python程序设计 第3章：Python流程控制语句
惊鸿若梦一书生
01-23 3514
第3章 Python流程控制语句3.1 条件语句3.1.1 条件表达式3.1.2 单分支选择结构3.1.3 双分支选择结构3.1.4 多分支选择结构3.1.5 选择结构的嵌套3.1.6 三元表达式3.2 循环语句3.2.1 while循环3.2.2 while else循环3.2.3 for 循环3.2.4 for else循环3.3 循环控制语句3.3.1 break语句3.3.2 continue语句3.3.3 pass语句3.4 迭代器3.4.1 可迭代对象3.4.2 迭代器的定义3.4.3 迭代器的
第3章 - 课后习题 程序流程控制
Kuro_hane的博客
03-18 5169
Python语言程序设计教程 - 赵璐 上海交通大学出版社 第三章 程序流程控制 课后习题
第五章 程序流程控制
qq_39500356的博客
04-14 212
5.1 程序流程控制介绍 5.2 顺序控制 5.3 分支控制
python第三章 程序流程控制 课后习题
热门推荐
m0_51346837专栏
01-17 3万+
1 .三名面试者的基本数据如下： 序号 年龄 工作经验/年 所学专业 1 24 0 计算机 2 32 4 电子 3 36 8 电子 4 26 2 通信 分别输入每一位面试者的基本数据，输出是否符合面试要求，面试要求为： 计算机专业，年龄小于25岁 电子专业，有4年以上工作经验 通信专业都可以 满足面试要求的，输出“获得面试机会”，不满足要求的，输出“抱歉，您不符合面试要求” age=int(input("年龄：")) year=int(input("工作经历（年）："))
Scala核心编程 第四章—Scala程序流程控制概述
星星的博客
09-18 1万+
一、程序流程控制介绍 在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句。 Scala语言中控制结构和Java语言中的控制结构基本相同，在不考虑特殊应用场景的情况下，代码书写方式以及理解方式都没有太大的区别 1.顺序控制 （1）顺序控制介绍 程序从上到下逐行地执行，中间没有任何判断和跳转。 （2）顺序...
python语言程序设计教程赵璐 第三章 课后习题 程序流程控制
qq_55937474的博客
05-05 7483
# 1 age = int(input("请输入年龄：")) experience = int(input("请输入工作经验/年：")) major = input("请输入所学专业：") if major == "计算机" and age <= 25 or major == "电子" and experience >= 4 or major == "通信": print("获得面试机会") else: print("抱歉，您不符合面试要求") # 2 mark = eval(.
第 4 章 程序的控制结构
华仔仔的博客
01-21 3286
第 4 章 程序的控制结构1. 程序的三种控制结构1.1 程序流程图 1. 程序的三种控制结构 1.1 程序流程图 程序流程图是一种表达程序控制结构的方式，主要用于关键部分的程序分析和过程描述，由一系列图形、流程线和文字说明等组成。 流程图的 7 种基本元素如下表所示： 图形 描述 ...
第五章 程序控制结构
yirenyuan的博客
06-26 752
一、程序流程控制介绍 | 二、switch 分支结构 | 三、for 循环控制 | 四、while 循环控制 | 五、do...while 循环控制 | 六、跳转控制语句 |
第四章 程序的控制结构
m0_51775887的博客
11-07 930
4.1程序的三种控制结构 4.1.1程序流程图 基本元素:起止框、判断框、处理框、输入输出框、注释框、流向框、连接点 4.1.2程序控制结构基础 三种基本结构组成：顺序结构、分支结构和循环结构 4.1.3程序控制结构拓展 在分支结构原理的基础上，Python增加了异常处理，使用try-except保留字，异常处理以程序运是否为异常为判断条件，根据一段代码执行正确性进行程序逻辑选择 在循环结构原理基础上，Python提供两个循环控制符break和continue对循环的执行程序进行控制。break控制符用来
第四章 流程控制
Edison772的博客
01-23 4760
一、要点总结 流程控制语句：复合语句、条件语句、循环语句。 使用复合语句可以为变量定义一个有效区域； 通过使用if与switch语句，可以基于布尔类型的测试，将一个程序分成不同的部分； 通过while、do...while循环语句和for循环语句，可以让程序的一部分重复的执行，直到满足某个终止循环的条件。 二、几个小练习 1、计算1+1/2!+1/3!...+1/20! /** * 计算1+1/2!+1/3!...+1/20! * @author DELL * */ public c
【Python学习笔记】第五章 程序流程控制.pdf
02-06
主要介绍了程序流程控制方面的内容，了解如何控制程序的流程，使得程序员具有很好的判断能力。
第三章java流程控制语句.ppt
11-12
Java 流程控制语句是 Java 语言中控制程序执行顺序的语句，是程序中非常关键和基本的部分。该类型的语句可以把单个的语句组合成有意义的、能够完成一定功能的小逻辑块。 一、Java 语句概述 Java 语言是一种面向...
第4章 MATLAB程序流程控制_习题答案.pdf
07-07
在MATLAB编程中，程序流程控制是实现复杂算法的关键部分，包括条件语句、循环语句以及函数调用等。 1. 脚本文件与函数文件： - 脚本文件（Script File）是一系列MATLAB命令的集合，可以直接在命令行窗口运行，不...
电气控制与可编程序控制器第5章.ppt
11-22
《电气控制与可编程序控制器第5章》主要讲解了CX-P编程软件的使用方法及其在电气控制系统中的应用。CX-P是Omron公司推出的一款专用于编写和调试PLC（可编程逻辑控制器）程序的软件工具，具有直观的用户界面和丰富的...
Golang 泛型详解
07-25 868
/ 自定义一个新类型 MapTT：类型形参。定义 MapT 时 T 代表的类型并不确定，类似一个占位符。：类型约束。指定 T 仅可接受哪些类型。中括号内定义形参类型，称为形参类型列表。其中，类型约束可以包上 interface{}m[T] = valreturn m// 或简写为type T interface{int|int32|float32|string} // 自定义类型约束。
go语言day18 reflect反射
weixin_45939821的博客
07-25 1189
获取Value对象时使用指针，让Value中存储的是personObj对象属性的地址，才能修改personObj对象属性；同样都是获取类型，Kind()获取go包中已存在的类型，对于自定义的结构体类型只会显示struct.显示具体类型使用reflect.TypeOf()否则默认会浅拷贝一个对象，修改属性跟原对象不相干。
【VSCode实战】Golang无法跳转问题竟是如此简单
weixin_42206314的博客
07-26 841
workspace是golang1.18版本引入的新概念，就是VSCode打开的工作目录中，若是有多个mod文件，它会不知道使用哪一个，也就无法定位。但工作目录中，若是只有一个项目，那么它自然可以找到，也就可以正常“转到定义”。，开头说到了在VSCode中Golang无法跳转的问题，但文章的最后也没给出解决方案，只解决了安装Go插件的依赖问题。2.在已安装的扩展里面，找到Go扩展，点击右下角的齿轮标记，选择扩展设置，也会打开1的界面。无法跳转的问题，其实还是很简单的，只是被网上各种冗余信息误导了。
Golang | Leetcode Golang题解之第303题区域和检索-数组不可变
最新发布
weixin_66442839的博客
07-30 250
Golang | Leetcode Golang题解之第303题区域和检索-数组不可变
Golang 高性能 Websocket 库 gws 使用与设计（一）
qq_41468830的博客
07-27 686
GitHub 🌟 1.2k，高性能的 websocket 库，代码双语注释，适合有开发经验的同学进阶学习。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

闪耀的Cat

开发不易，请笔者喝瓶矿泉水

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值