目录
- 1. 程序流程控制
1. 程序流程控制
1.1 程序流程个控制介绍
在程序流程中,程序运行的流程控制决定程序是如何执行的,是我们必须掌握的,主要有三大流程控制语句。
-
顺序控制;
-
分支控制;
-
循环控制;
1.2 三大流程控制介绍及案例
1.2.1 顺序流程控制
1.2.1.1 顺利流程控制介绍
程序从上到下逐行地执行,中间没有任何判断和跳转。
1.2.1.2 顺序流程控制流程图
1.2.1.3 顺序流程控制案例
以下案例的代码中,没有判断,没有跳转,因此程序按照默认的流程执行,即顺利流程控制。
func main() {
var a int = 100
fmt.Println("a 的地址=", &a)
var ptr *int = &a
fmt.Println("ptr 的值=", *ptr)
}
1.2.1.4 顺序流程控制注意事项
Golang中定义变量时采用合法的前向引用。如:
正确形式:
func main() {
var num1 int = 10
var num2 int = num1 + 20
fmt.Println(num2)
}
错误形式:
func main() {
var num2 int = num1 + 20
var num1 int = 10
fmt.Println(num2)
}
1.2.2 分支控制
1.2.2.1 分支控制介绍
让程序有选择的执行,分支控制有三种;
-
单分支;
-
双分支;
-
多分支;
1.2.2.1.1 单分支
1.2.2.1.1.1 单分支基本语法
if 条件表达式 {
执行代码块
}
说明:当条件表达式为True
时,就会执行{}
的代码。注意{}
是必须有的,就算只写一行代码。
1.2.2.1.1.2 单分支案例
编写一个程序,可以输入人的年龄,如果年龄大于18岁,输出“年龄大于18”;
func main() {
var age byte
fmt.Println("请输入年龄:")
fmt.Scanln(&age)
if age > 18 {
fmt.Println("年龄大于18")
}
}
1.2.2.1.1.3 单分支流程图
1.2.2.1.1.4 单分支流细节说明
Golang的if还有一个强大的地方就是条件判断语句里面允许声明一个变量,这个变量的作用域只能在该条件逻辑块内,其他地方不起作用,比如以下案例;
func main() {
if age := 20; age > 18 {
fmt.Println("年龄大于18")
}
}
1.2.2.1.2 双分支
1.2.2.1.2.1 双分支基本语法
if 条件表达式 {
执行代码块1
} else {
执行代码块2
}
说明:当条件表达式成立,即执行代码块1。否则执行代码块2。{}
必须有。
1.2.2.1.2.2 双分支案例
编写一个程序,可以输入人的年龄,如果年龄大于18岁,输出“年龄大于18”,否则输出“年龄小于18”;
func main() {
if age := 20; age > 18 {
fmt.Println("年龄大于18")
} else {
fmt.Println("年龄小于18")
}
}
1.2.2.1.2.3 双分支流程图
1.2.2.1.3 多分支
1.2.2.1.3.1 多分支基本语法
if 条件表达式1 {
执行代码块1
} else if 条件表达式2 {
执行代码块2
...
} else {
执行代码块N
}
说明:
-
多分支的判断流程如下
-
先判断条件表达式1是否成立,如果为真,就执行代码块1;
-
如果条件表达式1为假,就去判断条件表达式2是否成立,如果条件表达式2为真,就执行代码块2;
-
后面以此类推,如果所有的条件表达式不成立,则执行else的语句块;
-
-
else非必须;
-
多分支只能有一个执行入口;
1.2.2.1.3.2 多分支案例
小明参加考试,和父亲达成承诺:
-
成绩为100分时,奖励一辆BMW;
-
成绩为80-99分时,奖励一台iphone7 plus;
-
成绩为60-79分时,奖励一个ipad;
-
其他分时,什么奖励也没有;
请从键盘输入小明成绩,并加以判断
package main
import "fmt"
func main() {
var num1 int
fmt.Println("请输入小明成绩:")
fmt.Scanln(&num1)
if num1 == 100 {
fmt.Println("奖励一辆BMW")
} else if num1 >= 80 && num1 < 100 {
fmt.Println("奖励一台iphone7 plus")
} else if num1 >= 60 && num1 < 80 {
fmt.Println("奖励一个ipad")
} else {
fmt.Println("什么奖励也没有")
}
}
1.2.2.1.3.3 多分支流程图
1.2.2.1.4 嵌套分支
1.2.2.1.4.1 嵌套分支基本语法
在一个分支结构中又完整的嵌套了另一个完整的分子结构,里面的分支的结构称为内层分支外面的分支结构称为外层分支。
if 条件表达式 {
if 条件表达式 {
} else {
}
}
1.2.2.1.4.2 嵌套分支案例
如果跑进8秒内进入决赛,否则淘汰,并根据性别进入不通的小组。
package main
import "fmt"
func main() {
var sec float32
var gen string
fmt.Println("请输入时间:")
fmt.Scanln(&sec)
fmt.Println("请输入性别:")
fmt.Scanln(&gen)
if sec < 8 {
if gen == "男" {
fmt.Println("进入男子组决赛")
} else if gen == "女" {
fmt.Println("进入女子组决赛")
}
} else {
fmt.Println("淘汰!")
}
}
1.2.2.1.5 switch分支结构
1.2.2.1.5.1 switch分支结构介绍
-
switch语句用于基本不同条件执行不同动作,每一个case分支都是唯一的,从上倒下逐一测试,直到匹配为止;
-
匹配项后面也不需要在加break;
1.2.2.1.5.2 switch分支结构基本语法
switch {
case 表达式1,表达式2...:
语句块1
case 表达式3,表达式4...:
语句块2
... // 可以有多个case语句
default:
语句块
}
1.2.2.1.5.3 switch分支结构流程图
1.2.2.1.5.4 switch分支结构案例
编写一个程序,程序可以接收一个字符,比如:a,b,c...,a表示星期一,b表示星期二...,根据用户的输入显示相应的信息。
package main
import (
"fmt"
)
func main() {
var inp byte
fmt.Println("请输入字符:")
// 这里接受的时候需要使用格式化类型接收
fmt.Scanf("%c", &inp)
switch inp {
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("星期不知道几")
}
}
1.2.2.1.5.4 switch分支结构细节
-
case后是一个表达式(即:常量值、变量、一个有返回值的函数等都可以);
-
case后的各个表达式的值的数据类型,必须和switch的表达式数据类型一致;
-
case后面可以带多个表达式,使用逗号间隔。比如case表达式1,表达式2等;
-
case后面的表达式如果是常量值(字面量),则要求不能重复;
-
case后面不需要带break,程序匹配到一个case后就会执行对应的代码块,然后退出switch,如果一个都匹配不到,则执行default;
-
default语句不是必须的;
-
switch后也可以不带表达式,类似if-else分支来使用;
-
switch后也可以直接声明/定义一个变量,分号结束,不推荐;
-
switch穿透fallthrough,如果在case语句块后增加fallthrough,则会继续执行下一个case,也叫switch穿透;
-
Type Switch:switch语句还可以被用于type-switch来判断某个interface变量中实际指向的变量类型
1.2.2.1.5.4 switch和if比较
-
如果判断的具体数字不多,而且符合整数、浮点数、字符、字符串这几种类型,建议使用switch语句,简洁高效;
-
其他情况:对区间判断和结果为bool类型的判断,使用if,if的使用范围更广;
1.2.3 循环控制
1.2.3.1 for循环控制
1.2.3.1.1 for循环控制介绍
让代码不断的循环执行,快速入门,打印十句“Hello world!”。
for i := 0; i < 10; i++ {
fmt.Println("Hello, World!")
}
1.2.3.1.2 for循环控制基本语法
for 循环变量初始化;循环条件;循环变量迭代{
循环操作(语句)
}
for语句执行过程如下:
1、先对表达式 1 赋初值;
2、判别赋值表达式 init 是否满足给定条件,若其值为真,满足循环条件,则执行循环体内语句,然后执行 post,进入第二次循环,再判别 condition;否则判断 condition 的值为假,不满足条件,就终止for循环,执行循环体外语句。
for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下:
for key, value := range oldMap {
newMap[key] = value
}
以上代码中的 key 和 value 是可以省略。
如果只想读取 key,格式如下:
for key := range oldMap
或者这样:
for key, _ := range oldMap
如果只想读取 value,格式如下:
for _, value := range oldMap
1.2.3.1.3 for循环控制流程图
1.2.3.1.4 for循环控制使用细节
-
循环条件是返回一个布尔值的表达式;
-
for循环的第二种使用方式;
for 循环判断条件 {
// 循环执行语句
}
将变量初始化和变量迭代写到其他位置
- for循环的第三种使用方式
for {
// 循环执行语句
}
写法等价for ; ; {}
是一个无限循环,通常需要配合break语句使用。
- Golang提供
for-range
的方式,可以方便遍历字符串和数组;
传统方式:
func main() {
str := "HelloWorld"
for i := 0; i < len(str); i++ {
fmt.Printf("i=%d val=%c\n", i, str[i])
}
}
如果我们的字符串含有中文,那么传统的遍历字符串方式,会出现乱码。因为传统的对字符串的遍历是按照字节来遍历,而一个汉子在UTF-8编码对应3个字节。如何解决,需要将str转换[]rune
切片。
func main() {
var str string = "HelloWorld你好世界"
str1 := []rune(str)
for i := 0; i < len(str1); i++ {
fmt.Printf("i=%d val=%c\n", i, str1[i])
}
}
for-range方式:
func main() {
str := "HelloWorld世界"
for index, val := range str {
fmt.Printf("index=%d val=%c\n", index, val)
}
}
注意:for-range
在遍历字符串时,是按照字符来遍历的,而不是按照字节,所以可以字节遍历中文。
1.2.3.2 while和do...while循环控制
1.2.3.2.1 while和do...while循环控制介绍
Golang语言没有while和do...while语法,可以通过for循环来实现相应效果。
for循环的while语法及案例:
循环变量初始化
for {
if 循环条件表达式 {
brek // 跳出for循环
}
循环操作(语句)
循环变量迭代
}
func main() {
var num int = 0
for {
if num > 10 {
break
}
fmt.Println("hello world")
num++
}
}
for循环的do...while语法及案例:
循环变量初始化
for {
循环操作(语句)
循环变量迭代
if 循环条件表达式 {
break // 跳出for循环
}
}
func main() {
var num int = 0
for {
fmt.Println("hello ok")
num++
if num > 10 {
break
}
}
}
说明:while和do...while的区别在于,while在不成立时可能一次都不会执行,do...while不管是否成立最少会执行一次。
1.2.3.3 多重循环控制
1.2.3.3.1 多重循环控制介绍
-
将一个循环放在另一个循环体内,就形成了嵌套循环。在外边的for称为外层循环在里面的for循环称为内层循环;(建议一般使用两层,最多不超过三层)
-
实质上,嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时,才会完全跳出内存循环,才可结束外层的当次循环,开始下一次的循环;
-
假设外层循环次数为m次,内层为n次,则内层循环体实质上需要执行
m * n = mn
次;
1.2.3.3.1 多重循环控制案例
- 统计三个班成绩情况,每个班有五名同学,求出各个班的平均分和所有班级的平均分,学生成绩从键盘输入;
func main() {
// 班级数量
var classNumber int = 2
// 学生数量
var studentNumber int = 5
// 所有班级的总分
var overallAverage float64
// 循环班级数量
for i := 1; i <= classNumber; i++ {
// 班级总分
var classAverage float64
// 循环学生数量
for j := 1; j <= studentNumber; j++ {
// 学生成绩
var score float64
// 接收学生成绩
fmt.Printf("请输入%d班级, 第%d位同学的成绩:\n", i, j)
fmt.Scanln(&score)
// 学生成绩相加赋值给班级总分
classAverage += score
}
// 班级平均分计算
fmt.Printf("%d班的平均分是: %f\n", i, classAverage/float64(studentNumber))
// 班级总分相加赋值给所有班级总分
overallAverage += classAverage
}
// 所有班级总分计算及平均分计算
fmt.Printf("所有班级的总分是:%v 所有班级的平均分是:%v", overallAverage, overallAverage/(float64(studentNumber)*float64(classNumber)))
}
- 统计三个班及格人数,每个班有五名同学;
func main() {
var classNumber int = 3
var studentNumber int = 5
// 及格总人数
var totalPassNumber int
for i := 1; i <= classNumber; i++ {
// 班级及格人数
var passNumber int
for j := 1; j <= studentNumber; j++ {
var score float64
fmt.Printf("请第%d个班级,第%d个同学输入成绩:\n", i, j)
fmt.Scanln(&score)
// 判断是否及格,及格在班级及格人数中加一
if score >= 60.0 {
passNumber++
}
}
fmt.Printf("第%d个班级,及格人数是: %d\n", i, passNumber)
totalPassNumber += passNumber
}
fmt.Printf("所有班级总及格人数是:%d\n", totalPassNumber)
}
- 打印金字塔,使用for循环完成以下案例,可以接收一个整数,表示层数,打印出金字塔;
1. 打印一个矩形
func main() {
// 控制层数
for i := 1; i <= 3; i++ {
// 控制打印数量
for j := 1; j <= 3; j++ {
fmt.Print("*")
}
fmt.Println("")
}
}
/*
打印结果:
***
***
***
*/
2. 打印半个金字塔
我们发现半个金字塔的每行的打印数量和行数相同,所以把控制打印的数量的常量,修改为当前行数的变量,这样每次都是根据行数的打印对应的数量。
func main() {
// 控制层数
for i := 1; i <= 3; i++ {
// 控制打印数量
for j := 1; j <= i; j++ {
fmt.Print("*")
}
fmt.Println("")
}
}
/*
打印结果:
*
**
***
*/
3. 打印整个金字塔
func main() {
// 控制层数
for i := 1; i <= 3; i++ {
// 控制空格数量
for k := 1; k <= 3-i; k++ {
fmt.Print(" ")
}
// 控制打印数量
for j := 1; j <= 2*i-1; j++ {
fmt.Print("*")
}
fmt.Println("")
}
}
/*
打印结果:
* 1 层 1 个 *, 规律:2 * 层数 - 1 空格 2 规律:所有层数 - 当前层数
*** 2 层 3 个 *,规律:2 * 层数 - 1 空格 1 规律:所有层数 - 当前层数
***** 3 层 5 个 *,规律:2 * 层数 - 1 空格 0 规律:所有层数 - 当前层数
*/
4. 将层数做成一个变量
func main() {
// 层数常量
var totalLevel int = 5
// 控制层数
for i := 1; i <= totalLevel; i++ {
// 控制空格数量
for k := 1; k <= totalLevel-i; k++ {
fmt.Print(" ")
}
// 控制打印数量
for j := 1; j <= 2*i-1; j++ {
fmt.Print("*")
}
fmt.Println("")
}
}
/*
打印结果:
*
***
*****
*******
*********
*/
5. 打印空心金字塔
预期打印:
*
* *
*****
分析:在我们给每行打印*号时,需要考虑是打印*还是打印空格。观察预期打印我们发现,每行的第一个和最后一个打印*号,其他部分打印空格。还发现最后一行打印全*号。
func main() {
// 层数常量
var totalLevel int = 5
// 控制层数
for i := 1; i <= totalLevel; i++ {
// 控制空格数量
for k := 1; k <= totalLevel-i; k++ {
fmt.Print(" ")
}
// 控制打印数量
for j := 1; j <= 2*i-1; j++ {
// 如果是在打印第一个、最后一个及最后一行,都打印*,其余都打印空格
if j == 1 || j == 2*i-1 || i == totalLevel{
fmt.Print("*")
} else {
fmt.Print(" ")
}
}
fmt.Println("")
}
}
/*
打印结果:
*
* *
* *
* *
*********
*/
- 打印九九乘法表
func main() {
for i := 1; i <= 9; i++ {
for j := 1; j <= i; j++ {
fmt.Printf("%v x %v = %v\t", j, i, i*j)
}
fmt.Println("")
}
}
1.2.4 跳转控制语句
1.2.4.1 break跳转控制
1.2.4.1.1 break跳转控制介绍
通过一个需求引出break,随机生成1-100的一个数,直到生成了99这个数,看看你一共用了几次?
分析:编写一个无限循环控制,然后不停的随机生成数,当生成99时,就退出这个无限循环。
func main() {
// 在Golang中,需要生成一个随机种子,否则返回的值总是固定的。
// time.Now().Unix():返回一个从1970/1/1 00:00到现在的一个秒数
var countNumber int
for {
rand.Seed(time.Now().UnixNano())
n := rand.Intn(100) + 1
fmt.Println(n)
countNumber++
if n == 99 {
break
}
}
fmt.Printf("生成99一共用了%d次", countNumber)
}
Go 语言中 break 语句用于以下两方面:
-
用于循环语句中跳出循环,并开始执行循环之后的语句。
-
break 在 switch(开关语句)中在执行一条 case 后跳出语句的作用。
-
在多重循环中,可以用标号 label 标出想 break 的循环。
1.2.4.1.2 break跳转控制语法
{ ...
break
...
}
1.2.4.1.3 break跳转控制流程图
1.2.4.1.4 break跳转控制细节说明
-
break语句出现在多层嵌套的语句块中时,可以通过标签指明要终止的是哪一层语句块;
-
标签的基本使用
func main() {
// 演示指定标签的形式来使用break
label1: //设置一个标签
for i := 0; i < 4; i++ {
for j := 0; j < 10; j++ {
if j == 2 {
// break 默认会跳出最近的for循环
break label1 // break后面可以指定标签,跳出标签对应的循环
}
fmt.Println("j=", j)
}
}
}
1.2.4.1.5 break跳转控制案例
- 100以内的数求和,求出当和第一次大于20的当前数。
func main() {
var sum int
for i := 1; i <= 100; i++ {
sum += i
if sum > 20 {
fmt.Println("当sum>20时,当前数是:", i)
break
}
}
}
- 实现登录验证,有三次机会,如果用户名为“张无忌”,密码“888”提示登录成功,否则提示还有几次机会。
func main() {
for i := 1; i <= 3; i++ {
var username string
var password string
fmt.Println("请输入用户和密码:")
fmt.Scanf("%v %v", &username, &password)
if username == "张无忌" && password == "888" {
fmt.Println("登录成功!!!")
break
}
fmt.Printf("登录失败,还有%d次机会\n", 3-i)
}
}
1.2.4.2 continue跳转控制
1.2.4.2.1 continue跳转控制介绍
-
continue语句用于结束本次循环,继续执行下一次循环;
-
continue语句出现在多层嵌套的循环语句体中时,可以通过标签指明要跳过的哪一层循环,这个和前面的标签使用的规则一样。
1.2.4.2.2 continue跳转控制语法
{ ...
continue
...
}
1.2.4.2.2 continue跳转控制流程图
1.2.4.2.2 continue跳转控制案例
- 实现打印1-100的奇数,使用for循环+continue
func main() {
for i := 1; i <= 100; i++ {
if i%2 == 0 {
continue
}
fmt.Println(i)
}
}
- 从键盘读入个数不确定的整数,并判断读入的正数和负数的个数,输入为0时结束进程,使用for循环、break和continue完成。
func main() {
var positiveNumber int
var negaiveNumber int
for {
var num int
fmt.Println("请输入一个整数:")
fmt.Scanln(&num)
if num == 0 {
break
} else if num > 0 {
positiveNumber++
continue
}
negaiveNumber++
}
fmt.Printf("正数个数:%d 负数个数:%d\n", positiveNumber, negaiveNumber)
}
- 某人有100,000元,每经过一次路口,需要缴费,规则:当现金>50000,每次交5%;当现金<=50000,每次交1000;计算该人可以经过多少次路口,使用for和break方式完成。
func main() {
var intersections int
var money float64 = 100000
for {
if money <= 0 {
break
} else if money > 50000 {
money = money - (money * 0.05)
} else if money <= 50000 {
money -= 1000
}
intersections++
}
fmt.Printf("一共走过了%d个路口", intersections)
}
1.2.4.3 goto跳转控制
1.2.4.3.1 goto跳转控制介绍
-
Golang语言的goto语句可以无条件地转移到程序中指定的行;
-
goto语句通常与条件语句配合使用,可用来实现条件转移,跳出循环体等功能;
-
在Golang程序设计中一般不主张使用goto语句,以免造成程序流程的混乱,使理解和调试程序都产生困难;
1.2.4.3.2 goto跳转控制语法
goto label
...
label:statement
1.2.4.3.2 goto跳转控制案例
func main() {
var n int = 10
fmt.Println("ok1")
if n == 10 {
goto label1
}
fmt.Println("ok2")
fmt.Println("ok3")
label1:
fmt.Println("ok4")
fmt.Println("ok5")
}
1.2.4.4 return跳转控制
1.2.4.4.1 return跳转控制介绍
return使用在方法,表示跳出所在的函数或方法。
1.2.4.4.2 return跳转控制案例
func main() {
for i := 1; i < 10; i++ {
if i == 2 {
return
}
fmt.Println(i)
}
fmt.Println("Hello, world!")
}
标签:1.2,fmt,编程,程序流程,Golang,循环,跳转,Println,2.1
From: https://www.cnblogs.com/aadam/p/17032927.html