目录
一、概述
三大流程控制语句
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函数,也就是说终止程序
干我们这行,啥时候懈怠,就意味着长进的停止,长进的停止就意味着被淘汰,只能往前冲,直到凤凰涅槃的一天!