Golang流程控制

最新推荐文章于 2023-07-14 22:09:56 发布

楚江云

最新推荐文章于 2023-07-14 22:09:56 发布

阅读量321

点赞数

分类专栏： Golang 文章标签： Go Golang if判断 for循环 switch条件

楚江云

本文链接：https://blog.csdn.net/weixin_37717557/article/details/102872640

版权

Golang 专栏收录该内容

39 篇文章 5 订阅

订阅专栏

文章目录

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

楚江云

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
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 continue6. 跳转1. 概述程序中的流程控制语句,用于设置程序的执行次序,体现程序执行流程的实现部...
复制链接

扫一扫