Golang流程控制

文章目录

1. 概述2. 条件判断分支- if2.1 单分支2.2 双分支2.3 多分支 3. 条件选择分支- switch4. 循环控制-for4.1 标准的for循环4.2 for 无限循环4.3 for 循环嵌套4.4 for-range 遍历 5. 循环控制5.1 break5.2 continue 6. 跳转

1. 概述

程序中的流程控制语句,用于设置程序的执行次序,体现程序执行流程的实现部分,建立程序的基本逻辑结构.

2. 条件判断分支- if

Go语言中使用 if 关键字进行条件判断 ,条件判断的语句终值为 true 或者 false

2.1 单分支

语法格式 :

if 表达式 {

分支1

}

package main import "fmt" func main(){ var condition bool = true age := 19 if condition { fmt.Println("condition is true ") } if age >= 18{ fmt.Println("成年人的世界,没有容易二字") } // 也可以使用 ! 进行反向判断 if !(1>2){ fmt.Println("1不大于2") } } $ go run main.go condition is true 成年人的世界,没有容易二字 1不大于2

if 后面的条件判断语句可以是一个表达式

package main import "fmt" func compareNum(x, y int) bool { if x < y { return false } return true } func main() { // if 后面的可以是一个表达式 if month := 8; month <= 9 { fmt.Printf("现在是%d月份\n", month) } x := 90 y := 10 // 也是一个表达式 if compareNum(x, y) { fmt.Printf("x = %d 大于 y = %d\n", x, y) } } $ go run main.go 现在是8月份 x = 90 大于 y = 10

2.2 双分支

语法格式 :

if 表达式{

​ 分支1

}else{

​ 分支2

}

package main import "fmt" func main(){ var age int fmt.Println("请输入年龄[0~120] : ") fmt.Scanln(&age) if age >18{ fmt.Println("成年人") }else{ fmt.Println("未成年人") } } $ go run main.go 请输入年龄[0~120] : 99 成年人

注意 if后面跟的表达式的形式的最终结果是bool类型,不论表达式以怎么样的形式出现

package main import "fmt" func main() { var n1 float64 = 89.99 var n2 float64 = 10.01 b := true if n1 >= 88.00 || n2 < 11.00 && (n1+n2) > 99.99 && b { fmt.Println("条件都满足") } else { fmt.Println("条件都不满足") } } $ go run main.go 条件都满足

2.3 多分支

多分支控制

if 表达式1 {

​ 分支1

}else if 表达式2{

​ 分支2

}else if 表达式3{

​ 分支3

}…

package main import "fmt" func main() { var score int fmt.Println("请输入学生分数[0~100] : ") fmt.Scanln(&score) if score > 100 || score < 0 { fmt.Println("分数范围不正确") } else if score >= 90 { fmt.Println("成绩优秀") } else if score >= 80 { fmt.Println("成绩良好") } else if score >= 70{ fmt.Println("成绩普通") } else if score >= 60 { fmt.Println("成绩及格") }else{ fmt.Println("成绩不及格") } } $ go run main.go 请输入学生分数[0~100] : 76 成绩普通

3. 条件选择分支- switch

switch是根据不同的执行条件,执行不同的逻辑分支代码,每个case分支都是唯一的,自上而下逐一匹配

switch 和case 的表达式可以是 常量,变量,也可以是表达式Go语言中的switch语句中的case分支,结尾处不需要break(和其他编程语言有区别)case后面表达式的数据类型,必须和switch的表达式一致case后面的表达式可以是多个,使用逗号隔开switch中default 也可以不需要switch后面也可以没有表式,此种情况下整个switch结构和if…else…逻辑作用等同

示例1

package main import "fmt" func main(){ var n int fmt.Println("please input number[1~7]: ") fmt.Scanln(&n) switch n { case 1: fmt.Println("Monday") case 2: fmt.Println("Tuesday") case 3: fmt.Println("Wednesday") case 4: fmt.Println("Thursday") case 5: fmt.Println("Friday") case 6: fmt.Println("Saturday") case 7 : fmt.Println("Sunday") default : fmt.Println("Unknown") } } $go run main.go please input number[1~7]: 7 Sunday

示例2

package main import "fmt" func main(){ var n int fmt.Println("please input number[1~10]: ") fmt.Scanln(&n) switch n { case 2,4,6,8,10: fmt.Println("even number") case 1,3,5,7,9: fmt.Println("Odd number") default : fmt.Println("Unknown") } }

示例3

package main import "fmt" func compareNum(x, y int) int { if x > y { return x } else if y > x { return y } return 0 } func main() { var x int var y int fmt.Println("input two number x = ? and y = ?:") fmt.Scanln(&x, &y) switch { case compareNum(x, y) == x: fmt.Println("x is big") case compareNum(x, y) == y: fmt.Println("y is big") case compareNum(x, y) == 0: fmt.Println("x == y") } } $ go run main.go input two number x = ? and y = ?: 90 90 x == y

fallthrough穿透 : 在case语句后面增加fallthrough会继续执行下一个case的内容

package main import "fmt" func main() { var passWorld string = "root123456" switch { case passWorld == "root123456": fmt.Println("passworld is ok") fallthrough case passWorld != "root123456": fmt.Println("passworld is error") fallthrough default: fmt.Println("passworld is null") } } $ go run main.go passworld is ok passworld is error passworld is null

4. 循环控制-for

Go语言循环只支for关键字,不支持while和do…while结构

语法格式

for 循环变量初始化 ; 循环控制条件 ; 循环变量变化语句{

​ 循环体语句

}

一般的for 循环中循环体不断的执行,直到循环控制条件不成立,for循环结束for循环可以通过break ,goto,return,panic等语句退出循环无限循环也是通过for关键字实现,通常会配合一些结束条件

4.1 标准的for循环

package main import "fmt" func main(){ // 求1到100整数的累加和 // 写法1 标准的for循环写法 var sum1 int = 0 for i:=1;i<=100 ;i++ { sum1 += i } fmt.Println("写法1:从1累加到100的和是 : ",sum1) // 写法2 var sum2 int = 0 i := 1 for i<=100{ sum2 +=i i++ } fmt.Println("写法2:从1累加到100的和是 : ",sum2) // 写法3 var sum3 int = 0 j := 1 for ;;j++{ if j>100{ break } sum3 += j } fmt.Println("写法3:从1累加到100的和是 : ",sum3) } $ go run main.go 写法1:从1累加到100的和是 : 5050 写法2:从1累加到100的和是 : 5050 写法3:从1累加到100的和是 : 5050

4.2 for 无限循环

实现类似do…while

package main import "fmt" func main(){ i:= 0 for{ if i>10{ break } fmt.Println("i = ",i) i++ } } $ go run main.go i = 0 i = 1 i = 2 i = 3 i = 4 i = 5 i = 6 i = 7 i = 8 i = 9 i = 10

4.3 for 循环嵌套

package main import "fmt" func main() { // 打印一个九九乘法表 for i := 1; i <= 9; i++ { for j := 1; j <= i; j++ { fmt.Printf("%d X %d = %d\t", j, i, i*j) } fmt.Println() } } $ go run main.go 1 X 1 = 1 1 X 2 = 2 2 X 2 = 4 1 X 3 = 3 2 X 3 = 6 3 X 3 = 9 1 X 4 = 4 2 X 4 = 8 3 X 4 = 12 4 X 4 = 16 1 X 5 = 5 2 X 5 = 10 3 X 5 = 15 4 X 5 = 20 5 X 5 = 25 1 X 6 = 6 2 X 6 = 12 3 X 6 = 18 4 X 6 = 24 5 X 6 = 30 6 X 6 = 36 1 X 7 = 7 2 X 7 = 14 3 X 7 = 21 4 X 7 = 28 5 X 7 = 35 6 X 7 = 42 7 X 7 = 49 1 X 8 = 8 2 X 8 = 16 3 X 8 = 24 4 X 8 = 32 5 X 8 = 40 6 X 8 = 48 7 X 8 = 56 8 X 8 = 64 1 X 9 = 9 2 X 9 = 18 3 X 9 = 27 4 X 9 = 36 5 X 9 = 45 6 X 9 = 54 7 X 9 = 63 8 X 9 = 72 9 X 9 = 81

4.4 for-range 遍历

for循环配合for…range语句结构可以遍历字符串,数组,切片,map和通道(channel)

package main import "fmt" func main() { // for-range遍历 // 遍历字符串 var str string = "golang中国" fmt.Println("遍历字符串 :") for k, v := range str { fmt.Printf("%d==>%c\t", k, v) } //遍历数组 var arr = [...]string{"one", "two", "three"} fmt.Printf("\n遍历数组 :\n") for k, v := range arr { fmt.Printf("%d==>%s\t", k, v) } // 遍历切片 var sli []string = []string{"A", "B", "C"} fmt.Printf("\n遍历切片 :\n") for k, v := range sli { fmt.Printf("%d==>%s\t", k, v) } fmt.Printf("\n遍历map :\n") // 遍历map var personalInfo = map[string]string{ "name": "tom", "addr": "beijing", "cardNo": "471823781238812389X", } for k, v := range personalInfo { fmt.Printf("%s:%s\n", k, v) } } $ go run main.go 遍历字符串 : 0==>g 1==>o 2==>l 3==>a 4==>n 5==>g 6==>中 9==>国 遍历数组 : 0==>one 1==>two 2==>three 遍历切片 : 0==>A 1==>B 2==>C 遍历map : addr:beijing cardNo:471823781238812389X name:tom

遍历channel

package main import "fmt" func main() { c := make(chan string) go func() { c<-"AA" c<-"BB" c<-"CC" c<-"DD" close(c) }() for v := range c{ fmt.Println(v) } } $ go run main.go AA BB CC DD

5. 循环控制

5.1 break

break 语句可以结束for 的代码块,break 可以在后面添加标签,表示退出某个标签的代码块

package main import ( "fmt" "math/rand" "time" ) func main(){ // 初始化一个变量当做计数器 count := 0 for{ rand.Seed(time.Now().UnixNano()) n := rand.Intn(10000)+1 fmt.Println("n = ",n) count++ if n == 88{ break } } fmt.Printf("生成88一共执行了%d次",count) } $ go run main.go n = 88 生成88一共执行了468640次

break 通过标签指明要终止的语句块

break 默认跳出最近的for循环break 指定跳出标签,跳出标签对应的for循环 package main import "fmt" func main() { LL_1: for i := 0; i < 5; i++ { fmt.Printf("i=%d\n",i) LL_2: for j := 0; j <= 10; j++ { fmt.Printf("\tj=%d\n",j) if i == 2{ break LL_1 } for k:=0;k<=10 ;k++ { fmt.Printf("\t\tk=%d\n",k) if k == 3{ break LL_2 } } } } fmt.Println("golang") } $ go run main.go i=0 j=0 k=0 k=1 k=2 k=3 i=1 j=0 k=0 k=1 k=2 k=3 i=2 j=0 golang

5.2 continue

continue语句表示跳出本次循环,进入下一个循环中

package main import "fmt" func main(){ for i:=0;i<=10;i++{ for j:=0;j<10;j++{ if (i*j)%2==0{ continue } fmt.Printf("%d * %d = %d\n",j,i,j*i) } } }

continue 后面也可添加标签, 指明要跳过那一层循环

package main import "fmt" func main(){ LOOP: for i:=0;i<=5;i++{ for j:=0;j<5;j++{ switch j { case 2: fmt.Println(i,j) continue LOOP } } } } $ go run main.go 0 2 1 2 2 2 3 2 4 2 5 2

6. 跳转

Go语言中goto语句可以直接跳转到指定的行

package main import "fmt" func main() { for i:= 0;i<20 ;i++{ fmt.Println("Loop :",i) if i == 5{ goto Here } } fmt.Println("A") fmt.Println("B") Here: fmt.Println("it is over") fmt.Println("main process is over") } $ go run main.go Loop : 0 Loop : 1 Loop : 2 Loop : 3 Loop : 4 Loop : 5 it is over main process is over

goto的一个应用场景 : 错误统一处理

package main import ( "errors" "fmt" ) func checkError1()error{ return errors.New("checkError_1 error") } func checkError2()error{ return errors.New("checkError_2 error") } func main(){ err := checkError1() if err != nil{ goto operateError } err = checkError2() if err != nil{ goto operateError } fmt.Println("program is ok") operateError: fmt.Println(err) } $ go run main.go checkError_1 error