Golang学习+深入(六)-程序流程控制
目录
一、概述
1、顺序控制
2、分支控制
2.1、if分支控制
2.2、switch分支控制
3、循环控制
1、for循环控制
2、while和do...while的实现
3、多重循环控制
跳转控制语句
1、跳转控制语句-break
2、跳转控制语句-continue
3、跳转控制语句-goto
4、跳转控制语句-return
一、概述
三大流程控制语句
1、顺序控制
程序从上到下逐行地执行，中间没有任何判断和跳转。
Golang中定义变量时采用合法的向前引用。(先定义后引用，不能先引用后定义。)
2、分支控制
2.1、if分支控制
1、单分支
基本语法:
if 条件表达式 {
代码块
}
说明:条件表达式为true,就会执行{}的代码
注意{}是必须有的就算只写一行代码。
Go的if还有一个强大的地方就是条件判断语句里面允许声明一个变量,这个变量的作用域只能在该条件逻辑块内，其他地方就不起作用了。
if age :=20; age>18 {
fmt.Println("age=",age)
}2、双分支
基本语法:
if 条件表达式 {
代码块1
} else {
代码块2
}
说明:{}必须有的。3、多分支
基本语法:
if 条件表达式 {
代码块1
} else if 条件表达式{
代码块2
}
....
} else {
代码块n
}
说明:{}必须有的。4、嵌套分支
一个分支语句中嵌套了另一个分支语句。嵌套分支不宜过多，建议控制在3层内。
2.2、switch分支控制
- switch语句用于基于不同条件执行不同动作，每一个case分支都是唯一的，从上到下逐一测试，直到匹配为止。
- 匹配项后面也不需要再加break,case后面不需要带break，程序匹配到一个case后就会执行对应的代码块，然后退出switch，如果一个都匹配不到，则执行default。
- case后的各个表达式的值的数据类型，必须和switch的表达式数据类型一致。
- default语句不是必须有的。
- switch后可以不带表达式，类似if-else分支来使用
- switch后也可以直接声明一个变量，分号结束，不推荐使用。
- switch穿透fallthrough,如果在case语句块后增加fallthrough，则会继续执行下一个case，也叫switch穿透。fallthrough默认只能穿透一层。
- Type switch：switch语句还可以被用于type-switch来判断某个interface变量中实际指向的变量类型。
switch 表达式 {
case 表达式1,表达式2,....:
语句块1
case 表达式3,表达式24,....:
语句块2
.....
default:
语句块n
}package main
import (
"fmt"
)
func main() {
var x interface{}
var y = 10.0
x = y
switch i := x.(type) {
case nil:
fmt.Println("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的类型%T",i)
default:
fmt.Println("未知类型")
}
}3、循环控制
1、for循环控制
基本语法:
方式1:循环条件是返回一个布尔值的表达式
for 循环变量初始化;循环条件;循环变量迭代 {
循环操作体
}
方式2:变量初始化和变量迭代写到其他地方
for 循环条件 {
循环操作体
}
方式3:等价for ; ;{}是一个无限循环，通常需要配合break语句使用
for {
循环操作体
}
方式4:for-range遍历字符串和数组
str :="hello world!"
for index,val := range str {
fmt.Printf("index=%d val=%c\n",index,val)
}
for-range遍历字符串时，是按照字符来遍历的，而不是按照字节来的。2、while和do...while的实现
Go语言没有while和do...while的实现，使用for循环来实现的。
1、for循环实现while的效果
for {
if 循环条件表达式 {
break//跳出for循环
}
循环操作体
循环遍历迭代
}
2、for循环实现do...while的效果
for {
循环操作体
循环遍历迭代
if 循环条件表达式 {
break//跳出for循环
}
}
//先执行，后判断，因此至少执行一次。3、多重循环控制
- 将一个循环放在另一个循环体内，就形成了嵌套循环。建议一般使用2层，最多不要超过3层。
- 嵌套循环就是把内层循环当成外层循环的循环体
- 外层循环次数m次，内层循环n次，则内层循环体实际上要执行m*n=mn次
//打印空心金字塔
//空格数量=总层数-当前层数
//每层*数量=2*层数-1
package main
import (
"fmt"
)
func main() {
var totalLevel int =10
for i := 1; i <= totalLevel; i++ {
for j :=1; j<=totalLevel -i; j++{
fmt.Print(" ")
}
for k := 1; k <= 2*i-1; k++{
if k == 1 || k==2*i-1 || i == totalLevel{
fmt.Print("*")
}else{
fmt.Print(" ")
}
}
fmt.Println()
}
}//打印九九乘法表
package main
import (
"fmt"
)
func main() {
for i:=1;i<=9;i++{
for j:=1;j<=i;j++{
fmt.Printf("%v * %v = %v \t",j,i,i*j)
}
fmt.Println()
}
}跳转控制语句
1、跳转控制语句-break
- break语句用于终止某个语句块的执行，用于中断当前for循环或跳出switch语句。
- break语句出现在多层嵌套语句块时，可以通过标签指明要终止的是哪一层语句块
- break 默认跳出最近的for循环
- break 后面指定标签，跳出标签对应的for循环
标签的基本使用
label1:{
label2:{
label3:{
break label2
}
}
}
======================================
package main
import (
"fmt"
)
func main() {
label:
for i := 0;i < 4;i++{
for j := 0;j < 10;j++{
if j == 2 {
break label
}
fmt.Println("j=",j)
}
}
}2、跳转控制语句-continue
- continue语句用于结束本次循环，继续执行下一次循环。
- continue语句出现在多层嵌套的循环语句体中，可以通过标签指明要跳过的是哪一层循环，这个和前面标签使用规则一样。
3、跳转控制语句-goto
- Go语言的goto语句可以无条件地转移到程序中指定的行。
- goto语句通常与条件语句配合使用。可用来实现条件转移，跳出循环体等功能。
- 在Go程序设计中一般不主张使用goto语句，以免造成程序流程的混乱，使理解和调试程序都产生困难
基本语法:
goto label
....
label:statement
====================================
package main
import (
"fmt"
)
func main() {
var i = 1
fmt.Println(1)
fmt.Println(2)
fmt.Println(3)
goto label1
fmt.Println(4)
label1:
fmt.Println(5)
fmt.Println(6)
label2:
fmt.Println(7)
fmt.Println(8)
if i==1{
i++
goto label2
}
fmt.Println(9)
}4、跳转控制语句-return
- return使用在方法或者函数，表示跳出所在的函数或方法。
- 如果return是在普通的函数，则表示跳出该函数，即不再执行函数中return后面的代码，也可以理解为终止函数。
- 如果return是在main函数，表示终止main函数，也就是说终止程序
干我们这行，啥时候懈怠，就意味着长进的停止，长进的停止就意味着被淘汰，只能往前冲，直到凤凰涅槃的一天！