golang流程控制总结

2021/12/8 13:17:08

编程Tag： go

本文主要是介绍golang流程控制总结，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

go语言中的流程控制

本文视频教程地址：https://www.bilibili.com/video/BV1zR4y1t7Wj?from=search&seid=12495842889998176802&spm_id_from=333.337.0.0

go语言中的条件

条件语句是用来判断给定的条件是否满足(表达式值是否为true或者false)，并根据判断的结果(真或假)决定执行的语句，go语言中的条件语句也是这样的。

go语言中的条件语句包含如下几种情况

  1. if 语句：if 语句 由一个布尔表达式后紧跟一个或多个语句组成。
  2. if…else 语句: if 语句 后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。
  3. if 嵌套语句: 你可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。
  4. switch 语句: switch 语句用于基于不同条件执行不同动作。
  5. select 语句: select 语句类似于 switch 语句，但是select会随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。

go语言中的循环语句

go语言中的循环只有for循环，去除了while、do while循环，使用起来更加简洁。

  1. for循环。
  2. for range循环。

go语言中的流程控制关键字

  1. break
  2. continue
  3. goto

golang中的if语句

go语言中的if语句和其他语言中的类似，都是根据给定的条件表达式运算结果来，判断执行流程。

go语言if语句语法

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
}

注意：在go语言中 布尔表达式不用使用括号。

go语言if语句实例演示

根据布尔值flag判断

import "fmt"

func test1() {
	var flag = true
	if flag {
		fmt.Println("flag is true")
	}
	fmt.Printf("程序运行结束")
}

func main() {
	test1()
}

程序运行结果

flag is true
程序运行结束

根据年龄判断是否成年

package main

import "fmt"

func test2() {
	var age = 20
	if age > 18 {
		fmt.Println("你是成年人")
	}
	fmt.Printf("程序运行结束")
}

func main() {
	test2()
}

程序运行结果

你是成年人
程序运行结束

初始变量可以声明在布尔表达式里面，注意它的作用域

func test3() {
	if age := 20; age > 18 {
		fmt.Println("你是成年人")
	}
	fmt.Printf("程序运行结束")
}

func main() {
	// test1()
	// test2()
	test3()
}

程序运行结果

你是成年人
程序运行结束

注意：不能使用0或非0表示真假

func test4() {
	var i = 1
	if i { // 编译失败
		fmt.Println("here")
	}
	fmt.Printf("程序运行结束")
}

go语言if语句使用提示：

  1. 不需使用括号将条件包含起来
  2. 大括号{}必须存在，即使只有一行语句
  3. 左括号必须在if或else的同一行
  4. 在if之后，条件语句之前，可以添加变量初始化语句，使用；进行分隔

golang中的if else语句

go语言中的if else语句可以根据给定条件二选一。

go语言的if else语句语法

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
} else {
  /* 在布尔表达式为 false 时执行 */
}

go语言if else语句实例

比较两个数的大小

package main

import "fmt"

func f1() {
	a := 1
	b := 2
	if a > b {
		fmt.Printf("\"a>b\": %v\n", "a>b")
	} else {
		fmt.Printf("\"a<=b\": %v\n", "a<b")
	}
}

func main() {
	f1()
}

判断一个数是奇数还是偶数

func f2() {
	var s int
	fmt.Println("输入一个数字：")
	fmt.Scan(&s)

	if s%2 == 0 {
		fmt.Print("s 是偶数\n")
	} else {
		fmt.Print("s 不是偶数\n")
	}
	fmt.Print("s 的值是：", s)
}

判断一个人是否成年

func f3() {
	age := 20
	if age >= 18 {
		fmt.Println("你是成年人")
	} else {
		fmt.Println("你还未成年")
	}
}

特殊写法，在if前面添加执行语句

func f4() {
	if age := 20; age >= 18 {
		fmt.Println("你是成年人")
	} else {
		fmt.Println("你还未成年")
	}
}

go语言if语句使用提示：

  1. 不需使用括号将条件包含起来
  2. 大括号{}必须存在，即使只有一行语句
  3. 左括号必须在if或else的同一行
  4. 在if之后，条件语句之前，可以添加变量初始化语句，使用；进行分隔

golang中的if else if语句

go语言if语句可以进行多重嵌套使用，进行多重判断。

go语言中的if else if语法

if 布尔表达式1 {
    // do something
} else if 布尔表达式2 {
    // do something else
}else {
    // catch-all or default
}

go语言中的if else if语法实例

根据分数判断等级

func f5() {
	score := 80
	if score >= 60 && score <= 70 {
		fmt.Println("C")
	} else if score > 70 && score <= 90 {
		fmt.Println("B")
	} else {
		fmt.Println("A")
	}
}

程序运行结果

B

同样也可以写成这样

func f5() {
	if score := 80; score >= 60 && score <= 70 {
		fmt.Println("C")
	} else if score > 70 && score <= 90 {
		fmt.Println("B")
	} else {
		fmt.Println("A")
	}
}

输入星期几的第一个字母来判断一下是星期几，如果第一个字母一样，则继续判断第二个字母

func f6() {
	//  Monday Tuesday Wednesday Thursday Friday Saturday Sunday
	var c string
	fmt.Println("输入一个字符：")
	fmt.Scan(&c)

	if c == "S" {
		fmt.Println("输入第二个字符：")
		fmt.Scan(&c)
		if c == "a" {
			fmt.Println("Saturday")
		} else if c == "u" {
			fmt.Println("Sunday")
		} else {
			fmt.Println("输入错误")
		}
	} else if c == "F" {
		fmt.Println("Friday")
	} else if c == "M" {
		fmt.Println("Monday")
	} else if c == "T" {
		fmt.Println("输入第二个字符：")
		fmt.Scan(&c)
		if c == "u" {
			fmt.Println("Tuesday")
		} else if c == "h" {
			fmt.Println("Thursday")
		} else {
			fmt.Println("输入错误")
		}
	} else if c == "W" {
		fmt.Println("Wednesday")
	} else {
		fmt.Println("输入错误")
	}
}

golang中嵌套if语句

go语言if语句可以嵌套多级进行判断。

go语言if嵌套语法

if 布尔表达式 1 {
   /* 在布尔表达式 1 为 true 时执行 */
   if 布尔表达式 2 {
      /* 在布尔表达式 2 为 true 时执行 */
   }
}

go语言if嵌套实例

判断三个数的大小

package main

import "fmt"

// a>b a>c a
// b>a b>c b else c

func f1() {
	a := 100
	b := 200
	c := 3
	if a > b {
		if a > c {
			fmt.Println("a最大")
		}
	} else {
		if b > c {
			fmt.Println("b最大")
		} else {
			fmt.Println("c最大")
		}
	}
}

func main() {
	f1()
}

判断男生还是女生，还有是否成年

func f2() {
	// 判断男女生及年龄
	gender := "女生"
	age := 16
	if gender == "男生" {
		fmt.Println("男生")
		if age > 18 {
			fmt.Println("成年")
		} else {
			fmt.Println("未成年")
		}
	} else {
		fmt.Println("女生")
		if age > 18 {
			fmt.Println("成年")
		} else {
			fmt.Println("未成年")
		}
	}
}

golang switch语句

go语言中的switch语句，可以非常容易的判断多个值的情况。

go语言中switch语句的语法

switch var1 {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}

go语言中switch语句实例

判断成绩

func f() {
	grade := "A"
	switch grade {
	case "A":
		fmt.Println("优秀")
	case "B":
		fmt.Println("良好")
	default:
		fmt.Println("一般")
	}
}

运行结果

优秀

多条件匹配

go语言switch语句，可以同时匹配多个条件，中间用逗号分隔，有其中一个匹配成功即可。

func f() {
	day := 3
	switch day {
	case 1, 2, 3, 4, 5:
		fmt.Println("工作日")
	case 6, 7:
		fmt.Println("休息日")
	}
}

运行结果

工作日

case可以是条件表达式

func f() {
	score := 90
	switch {
	case score >= 90:
		fmt.Println("享受假期")
	case score < 90 && score >= 80:
		fmt.Println("好好学习吧！")
	default:
		fmt.Println("玩命学习！")
	}
}

运行结果

享受假期

fallthrough可以可以执行满足条件的下一个case

func f3() {
	a := 100
	switch a {
	case 100:
		fmt.Println("100")
		fallthrough
	case 200:
		fmt.Println("200")
	case 300:
		fmt.Println("300")
	default:
		fmt.Println("other")
	}
}

运行结果

100
200

go语言中switch语句的注意事项

  1. 支持多条件匹配
  2. 不同的 case 之间不使用 break 分隔，默认只会执行一个 case。
  3. 如果想要执行多个 case，需要使用 fallthrough 关键字，也可用 break 终止。
  4. 分支还可以使用表达式，例如：a>10.

golang for循环语句

go语言中的for循环，只有for关键字，去除了像其他语言中的while和do while.

go语言for循环语法

for 初始语句;条件表达式;结束语句{
    循环体语句
}

注意：for表达式不用加括号

go语言for循环实例

循环输出1到10

func f() {
	for i := 1; i <= 10; i++ {
		fmt.Printf("i: %v\n", i)
	}
}

运行结果

i: 1
i: 2
i: 3
i: 4
i: 5
i: 6
i: 7
i: 8
i: 9
i: 10

初始条件，可以写到外面

func f() {
	i := 1
	for ; i <= 10; i++ {
		fmt.Printf("i: %v\n", i)
	}
}

运行结果

i: 1
i: 2
i: 3
i: 4
i: 5
i: 6
i: 7
i: 8
i: 9
i: 10

初始条件和结束条件都可以省略

func f() {
	i := 1 // 初始条件
	for i <= 10 {
		fmt.Printf("i: %v\n", i)
		i++ // 结束条件
	}
}

运行结果

i: 1
i: 2
i: 3
i: 4
i: 5
i: 6
i: 7
i: 8
i: 9
i: 10

这种情况类似其他语言中的while循环

永真循环

func f() {
	for {
		fmt.Println("我一直在执行~")
	}
}

func main() {
	f()
}

运行结果

我一直在执行~
我一直在执行~
我一直在执行~
我一直在执行~
我一直在执行~
我一直在执行~
我一直在执行~
我一直在执行~
我一直在执行~
我一直在执行~
我一直在执行~
我一直在执行~
我一直在执行~
我一直在执行~
......

for循环可以通过break、goto、return、panic语句强制退出循环。

golang for range循环

Go语言中可以使用for range遍历数组、切片、字符串、map 及通道（channel）。 通过for range遍历的返回值有以下规律：

  1. 数组、切片、字符串返回索引和值。
  2. map返回键和值。
  3. 通道（channel）只返回通道内的值。

go语言for range实例

循环数组

func f() {
	var a = [5]int{1, 2, 3, 4, 5}
	for i, v := range a {
		fmt.Printf("i: %d, v: %v\n", i, v)
	}
}

func main() {
	f()
}

运行结果

i: 0, v: 1
i: 1, v: 2
i: 2, v: 3
i: 3, v: 4
i: 4, v: 5

循环字符串

func f() {
	var s = "多课网，go教程"
	for i, v := range s {
		fmt.Printf("i: %d, v: %c\n", i, v)
	}
	// %c 按照字符输出
}

func main() {
	f()
}

运行结果

i: 0, v: 多
i: 3, v: 课
i: 6, v: 网
i: 9, v: ，
i: 12, v: g
i: 13, v: o
i: 14, v: 教
i: 17, v: 程

循环切片

func f() {
	var s = []int{1, 2, 3, 4, 5}
	for i, v := range s {
		fmt.Printf("i, %d, v: %v\n", i, v)
	}
}

func main() {
	f()
}

循环map

func f() {
	m := make(map[string]string)
	m["name"] = "tom"
	m["age"] = "20"
	m["email"] = "tom@gmail.com"
	for k, v := range m {
		fmt.Printf("k: %v, v: %v\n", k, v)
	}
}

func main() {
	f()
}

运行结果

k: email, v: tom@gmail.com
k: name, v: tom
k: age, v: 20

golang流程控制关键字break

break语句可以结束for、switch和select的代码块。

go语言使用break注意事项

  1. 单独在select中使用break和不使用break没有啥区别。
  2. 单独在表达式switch语句，并且没有fallthough，使用break和不使用break没有啥区别。
  3. 单独在表达式switch语句，并且有fallthough，使用break能够终止fallthough后面的case语句的执行。
  4. 带标签的break，可以跳出多层select/ switch作用域。让break更加灵活，写法更加简单灵活，不需要使用控制变量一层一层跳出循环，没有带break的只能跳出当前语句块。

go语言break关键字实例

跳出for循环

func f() {
	for i := 0; i < 10; i++ {
		if i == 5 {
			break // 退出循环
		}
		fmt.Printf("i: %v\n", i)
	}
}

func main() {
	f()
}

运行结果

i: 0
i: 1
i: 2
i: 3
i: 4

跳出switch

func f() {
	i := 2
	switch i {
	case 1:
		fmt.Println("等于1")
		break
	case 2:
		fmt.Println("等于2")
		break
		fallthrough
	case 3:
		fmt.Println("等于3")
		break
	default:
		fmt.Println("不关心")
		break
	}
}
func main() {
	f()
}

运行结果

等于2

注释掉fallthrough上面的break，运行结果

等于2
等于3

跳转到标签处

func f() {
MY_LABEL:
	for i := 0; i < 10; i++ {
		if i == 5 {
			break MY_LABEL
		}
		fmt.Printf("%v\n", i)
	}
	fmt.Println("end...")
}
func main() {
	f()
}

运行结果

0
1
2
3
4
end...

golang关键字continue

continue只能用在循环中，在go中只能用在for循环中，它可以终止本次循环，进行下一次循环。

在 continue语句后添加标签时，表示开始标签对应的循环。

go语言continue实例

输出1到10之间的偶数

func f() {
	for i := 0; i < 10; i++ {
		if i%2 == 0 {
			fmt.Printf("i: %v\n", i)
		}
	}
}
func main() {
	f()
}

运行结果

i: 0
i: 2
i: 4
i: 6
i: 8

跳转到label

func f() {
	// MY_LABEL:
	for i := 0; i < 5; i++ {
	MY_LABEL:
		for j := 0; j < 5; j++ {
			if i == 2 && j == 2 {
				continue MY_LABEL
			}
			fmt.Printf("i=%d,j=%d\n", i, j)
		}
	}
}
func main() {
	f()
}

运行结果

i=0,j=0
i=0,j=1
i=0,j=2
i=0,j=3
i=0,j=4
i=1,j=0
i=1,j=1
i=1,j=2
i=1,j=3
i=1,j=4
i=2,j=0
i=2,j=1
i=2,j=3
i=2,j=4
i=3,j=0
i=3,j=1
i=3,j=2
i=3,j=3
i=3,j=4
i=4,j=0
i=4,j=1
i=4,j=2
i=4,j=3
i=4,j=4


这篇关于golang流程控制总结的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！


相关编程文章

更多>
本站官方QQ
官方QQ:
23002807

沪ICP备2023033072号-1

     

扫一扫关注最新编程教程