-
流程控制的作用:
流程控制语句是用来控制程序中各语句执行顺序的语句,可以把语句组合成能完成一定功能的小逻辑模块。 -
控制语句的分类:
控制语句分为三类:顺序、选择和循环。
“顺序结构”代表“先执行a,再执行b”的逻辑。
“条件判断结构”代表“如果…,则…”的逻辑。
“循环结构”代表“如果…,则再继续…”的逻辑。
三种流程控制语句就能表示所有的事情!不信,你可以试试拆分你遇到的各种事情。这三种基本逻辑结构是相互支撑的,它们共同构成了算法的基本结构,无论怎样复杂的逻辑结构,都可以通过它们来表达。所以任何一种高级语言都具备上述两种结构。
本章是大家真正进入编程界的“门票”。 -
流程控制的流程:
1 分支结构
1.1 单分支
基本语法
if 条件表达式 {
逻辑代码
}
当条件表达式为ture时,就会执行得的代码。
PS:条件表达式左右的()可以不写,也建议不写
PS:if和表达式中间,一定要有空格
PS:在Golang中,{}是必须有的,就算你只写一行代码。
案例讲解
func main() {
// 实现功能:如果口罩的库存小于30个,提示:库存不足:
/*var count int = 100
// 单分支:
if count < 30 {
fmt.Println("对不起,口罩存量不足")
}*/
//在golang里,if后面可以并列的加入变量的定义:
if count := 20; count < 30 {
fmt.Println("对不起,口罩存量不足")
}
}
输出:
对不起,口罩存量不足
1.2 双分支
基本语法
if 条件表达式 {
逻辑代码1
} else {
逻辑代码2
}
当条件表达式成立,即执行逻辑代码1,否则执行逻辑代码2。{}也是必须有的。
案例讲解
func main() {
var age byte
fmt.Println("请问你的年龄多少?")
fmt.Scanln(&age)
if age < 18 {
fmt.Println("你还没有成年!")
} else {
fmt.Println("你已经成年了!!")
}
}
输出:
请问你的年龄多少?
18
你已经成年了!!
1.3 多分支
基本语法
if 条件表达式1 {
逻辑代码1
} else if 条件表达式2 {
逻辑代码2
}
.......
else {
逻辑代码n
}
案例讲解
略。。。。。只是多了几个else,略了。。
1.4 switch分支
基本语法
switch 表达式 {
case 值1,值2,.….:
语句块1
case 值3,值4,...:
语句块2
....
default:
语句块
}
ps:case后是一个表达式(即:常量值、变量、一个有返回值的函数都可以)
ps:case后面可以有多个表达式
ps:case后面的表达式如果是常量值,则不能重复
补充:穿透-fallthrough,如果在case语句块后增加fallthrough,则会继续执行下一个case,也叫switch穿透
案例讲解
func main() {
// a,b,c,d,e,f,g
var week byte
fmt.Println("请输入一个字符,在a,b,c,d,e,f,g里:")
fmt.Scanf("%c", &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', 'g':
fmt.Println("周末休息日")
default:
fmt.Println("您的输入有误,请重新输入")
}
}
输出:
请输入一个字符,在a,b,c,d,e,f,g里:
f
周末休息日
2 循环结构
2.1 for循环
for循环语句是支持迭代的一种通用结构,是最有效、最灵活的循环结构。for循环在第一次反复之前要进行初始化,即执行初始表达式;随后,对布尔表达式进行判定,若判定结果为true,则执行循环体,否则,终止循环;最后在每一次反复的时候,进行某种形式的“步进”,即执行迭代因子。
语法结构:
for 初始表达式; 布尔表达式; 迭代因子 {
循环体;
}
- 初始化部分设置循环变量的初值
- 条件判断部分为任意布尔表达式
- 迭代因子控制循环变量的增减
简单使用:
func main() {
for a := 1; a <= 10; a++ {
fmt.Println("打印", a, "次")
}
}
输出:
打印 1 次
打印 2 次
打印 3 次
打印 4 次
打印 5 次
打印 6 次
打印 7 次
打印 8 次
打印 9 次
打印 10 次
注意事项:
-
循环条件是返回一个布尔值的表达式
-
for循环的第二种使用方式
for 循环判断条件 { // 循环执行语句 }
-
for循环的第三种使用方式
for { // 循环执行语句 }
这种方式等价
for ; ; {}
是一个无限循环,通常需要配合break
语句使用。 -
Golang提供for-range的方式,可以方便遍历字符串、数组、切片、字典等(注:数组的遍历,我们放到讲数组的时候再讲解),案例说明如何遍历字符串。
func main() { // 字符串遍历方式1-传统方式 var str string = "hello,world!" for i := 0; i < len(str); i++ { fmt.Printf("i的值为:%d ,str[i]的值为:%c \n", i, str[i]) } fmt.Println() // 字符串遍历方式2-for-range str = "abc~ok!" for index, val := range str { fmt.Printf("index=%d, val=%c \n", index, val) } }
**注意:**在使用 for-range 遍历字符串时,返回的 val 类型为 rune 类型,而不是 byte 类型。因为字符串在 Go 语言中是采用 UTF-8 编码,每个 rune 类型表示一个 Unicode 码点,可以正确地表示任何 Unicode 字符。因此,在处理和打印中文字符时,一定要注意字符编码的正确性。
2.2 while和dowhile的实现
while的实现:
for {
if 循环条件表达式 {
break // 跳出for循环..
}
循环操作(语句)
循环变量迭代
}
// 例子
func main() {
var i int = 1
for {
if i > 10 {
break // 跳出for循环..
}
fmt.Println("hello world") // 循环操作(语句)
i++ // 循环变量迭代
}
}
do while的实现
for {
循环操作(语句)
循环变量迭代
if 循环条件表达式 {
break // 跳出for循环..
}
}
// 例子
func main() {
var i int = 1
for {
fmt.Println("hello world")
i++
if i > 0 { // 故意的
break // 跳出for循环..
}
}
}
// 输出:hello world
2.3 经典案例——打印金字塔
func main() {
var n int
fmt.Println("请输入你想要显示的金字塔层数:")
fmt.Scanf("%d", &n)
for i := 1; i <= n; i++ {
// 打印空格
for j := 1; j <= n-i; j++ {
fmt.Print(" ")
}
// 打印星号
for k := 1; k <= 2*i-1; k++ {
fmt.Print("*")
}
fmt.Println() // 换行
}
}
输出:
请输入你想要显示的金字塔层数:
5
*
***
*****
*******
*********
2.4 经典案例——打印九九乘法表
func main() {
for i := 1; i <= 9; i++ {
for j := 1; j <= i; j++ {
fmt.Printf("%d*%d=%-2d ", j, i, i*j)
}
fmt.Println()
}
}
输出:
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
3 跳转控制语句
3.1 break
break在循环中的作用:
package main
import "fmt"
func main(){
//功能:求1-100的和,当和第一次超过300的时候,停止程序
var sum int = 0
for i := 1 ; i <= 100 ; i++ {
sum += i
fmt.Println(sum)
if sum >= 300 {
//停止正在执行的这个循环:
break
}
}
fmt.Println("-----ok")
}
总结:
1.switch分支中,每个case分支后都用break结束当前分支,但是在go语言中break可以省略不写。
2.break可以结束正在执行的循环
深入理解:
package main
import "fmt"
func main(){
//双重循环:
for i := 1; i <= 5; i++ {
for j := 2; j <= 4; j++ {
fmt.Printf("i: %v, j: %v \n",i,j)
if i == 2 && j == 2 {
break
}
}
}
}
总结:break的作用结束离它最近的循环
结果:
i: 1, j: 2
i: 1, j: 3
i: 1, j: 4
i: 2, j: 2
i: 3, j: 2
i: 3, j: 3
i: 3, j: 4
i: 4, j: 2
i: 4, j: 3
i: 4, j: 4
i: 5, j: 2
i: 5, j: 3
i: 5, j: 4
3.2 continue
func main() {
for i := 1; i <= 100; i++ {
if i%6 != 0 {
continue //结束本次循环,继续下一次循环
}
fmt.Println(i)
}
}
结论:continue的作用是结束离它近的那个循环当前循环,开始下一次循环
3.3 goto
- Golang的 goto 语句可以无条件地转移到程序中指定的行。
- goto语句通常与条件语句配合使用。可用来实现条件转移.
- 在Go程序设计中一般不建议使用goto语句,以免造成程序流程的混乱。
- 代码展示:
package main
import "fmt"
func main() {
var (
input string
count int
)
start:
fmt.Println("请输入一个合法的字符串:")
fmt.Scan(&input)
if input == "" {
goto start
}
for i := 0; i < len(input); i++ {
if input[i] == 'a' || input[i] == 'A' {
count++
}
}
fmt.Printf("字符串 \"%s\" 中包含 %d 个字母 \"a\"。\n", input, count)
}
以上代码实现了一个简单的统计字符串中字母 “a” 出现次数的程序。程序通过使用无限循环和 goto
语句,让用户输入一个字符串,如果输入的字符串为空,则返回 start
标签,继续要求用户输入。
当用户输入一个非空字符串时,程序开始统计其中字母 “a” 的个数,结束后输出结果。在这个过程中,goto
语句用于实现 “输入不为空时跳转到计算代码块” 的功能。这种方式在少数情况下可能比较有用,但要谨慎使用。
需要注意,过多的使用 goto
语句可能会导致程序阅读性和可维护性降低。因此,在实际编写代码时,应该尽可能避免使用 goto
语句,用更加结构化的语言特性来代替。
3.4 return
return
是 Go 语言中的一个关键字,用于结束当前函数或方法的执行,并返回结果(可选)。return
语句可以带有一个或多个返回值。同时,和其他语言不同的是,在 Go 语言中,return
语句可以被放在函数或方法中的任意位置。
return
语句的使用场景包括但不限于:
- 在函数或方法执行过程中,需要提前跳出函数或方法;
- 在函数或方法返回结果之前,需要对某些资源进行清理或释放;
- 函数或方法执行成功或失败后,需要返回相应结果给调用方;
- 函数或方法需要直接返回某个值,而不需要继续执行下去。
这里只讲解,提前跳出循环的案例:
func main() {
for i := 1; i <= 100; i++ {
fmt.Println(i)
if i == 4 {
return //结束当前的函数
}
}
fmt.Println("hello golang")
}
输出:
1
2
3
4
Over~~~文章来源:https://www.toymoban.com/news/detail-721986.html
第四章结束啦!!!下一步结构体,冲冲冲!!!文章来源地址https://www.toymoban.com/news/detail-721986.html
到了这里,关于Go学习第四章——程序流程控制的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!