Go语言流程控制

Posted 2021-08-08 极客江南

Go语言流程控制基本概念

• Go语言流程控制和C语言一样, 也有三大流程控制结构
  • 顺序结构(默认结构)
  • 选择结构(if / switch)
  • 循环结构(for)

---

选择结构if

• 和C语言不同的的是
  • 条件表达式的值必须是布尔类型(Go语言中没有非零即真的概念)
  • 条件表达式前面可以添加初始化语句
  • 不需要编写圆括号
  • 左大括号必须和条件语句在同一行
• 第一种格式:
  • 条件表达式结果为true,那么执行if后面{}中代码

if 初始化语句; 条件表达式{
    语句块;
}

package main
import "fmt"
func main() {
	// 如果后续需要用到age变量, 可以将变量放到if外面
	age := 18
	if age >= 18{
		fmt.Println("成年人")
	}
}

package main
import "fmt"
func main() {
	// 如果后续不需要用到age变量, 可以将变量放到条件表达式前面
	if age := 18; age >= 18{
		fmt.Println("成年人")
	}
}

• 第二种格式:
  • 条件表达式结果为true,那么执行if后面{}中代码
  • 否则执行else后面{}中代码

if 初始化语句; 条件表达式{
    语句块;
}else{
    语句块;
}

package main
import "fmt"
func main() {
	if age := 18;age >= 18 {
		fmt.Println("成年人")
	}else{
		fmt.Println("未成年人")
	}
}

• 第三种格式:
  • if后面条件表达式结果为true,那么执行if后面{}中代码
  • 否则判断else if条件表达式是否为true,为true执行else if后面{}中代码
  • 否则依次判断后续else if条件表达式是否为true,哪个为true就执行哪个else if后面{}中代码
  • 都不满足则执行else后面{}中代码

if 初始化语句; 条件表达式{
    语句块;
}else if 条件表达式{
    语句块;
}
... ...
else{
    语句块;
}

package main
import "fmt"
func main() {
	if age := 18;age > 55{
		fmt.Println("老年人")
	}else if age >= 40{
		fmt.Println("中年人")
	}else if age >= 18{
		fmt.Println("成年人")
	}else{
		fmt.Println("未成年人")
	}
}

• 值得一提的是Go语言中没有C语言中的三目运算符, 所以C语言中三目能干的在Go语言中都只能通过if else的形式来完成

---

选择结构switch

• 和C语言不同的的是
  • 和if一样,表达式前面可以添加初始化语句
  • 和if一样,不需要编写圆括号
  • 和if一样,左大括号必须和表达式在同一行
  • case表达式的值不一定要是常量, 甚至可以不用传递
  • 一个case后面可以有多个表达式, 满足其中一个就算匹配
  • case后面不需要添加break
  • 可以在case语句块最后添加fallthrough,实现case穿透
  • case后面定义变量不需要添加{}明确范围
• 格式

switch 初始化语句; 表达式{
  case 表达式1, 表达式2:
        语句块;
  case 表达式1, 表达式2:
        语句块;
  default:
        语句块;
}

package main
import "fmt"
func main() {
	switch num := 3;num {
		case 1:
			fmt.Println("星期一")
		case 2:
			fmt.Println("星期二")
		case 3:
			fmt.Println("星期三")
		case 4:
			fmt.Println("星期四")
		case 5:
			fmt.Println("星期五")
		case 6:
			fmt.Println("星期六")
		case 7:
			fmt.Println("星期日")
		default:
			fmt.Println("Other...")
	}
}

package main
import "fmt"
func main() {
	switch num := 3;num {
	case 1,2,3,4,5:
		fmt.Println("工作日")
	case 6,7:
		fmt.Println("非工作日")
	default:
		fmt.Println("Other...")
	}
}

• 注意点:
  • case后面不用编写break, 不会出现case穿透问题
  • 如果想让case穿透,必须在case语句块最后添加fallthrough关键

package main
import "fmt"
func main() {
	switch num := 3;num {
	case 1:
		fallthrough
	case 2:
		fallthrough
	case 3:
		fallthrough
	case 4:
		fallthrough
	case 5:
		fmt.Println("工作日")
	case 6:
		fallthrough
	case 7:
		fmt.Println("非工作日")
	default:
		fmt.Println("Other...")
	}
}

• case后面不仅仅可以放常量,还可以放变量和表达式

package main
import "fmt"
func main() {
	value := 2
	switch num:=1; num {
	case value: // 变量
		fmt.Println("num等于value")
	default:
		fmt.Println("num不等于value")
	}
}

package main
import "fmt"
func main() {
	value := 2
	switch num:=1; num {
	case getValue(): // 函数
		fmt.Println("num等于value")
	default:
		fmt.Println("num不等于value")
	}
}
func getValue() int {
	return 1
}

package main
import "fmt"
func main() {
	switch num:=18; {
		case num >=0 && num <=10: // 表达式
			fmt.Println("num是一个0~10之间的数")
		case num >10 && num <=20:
			fmt.Println("num是一个11~20之间的数")
		default:
			fmt.Println("num是一个大于20的数")
	}
}

• case后面定义变量不用添加{}明确作用于范围

package main
import "fmt"
func main() {
    switch num := 1;num {
	  case 1:
		value := 10 // 不会报错
		fmt.Println(value)
	  default:
		fmt.Println("Other...")
	}
}

• 其它特性和C语言一样

---

循环结构for

• 和C语言不同的的是
  • 和if一样,条件表达式的值必须是布尔类型
  • 和if一样,不需要编写圆括号
  • 和if一样,左大括号必须和表达式在同一行
• 格式:

for 初始化表达式；循环条件表达式；循环后的操作表达式 {
    循环体语句;
}

package main
import "fmt"
func main() {
	for i:=0; i<10; i++{
		fmt.Println(i)
	}
}

• Go语言中没有while/dowhile循环, 所以可以通过如下格式实现C语言中while循环用法

package main
import "fmt"
func main() {
	i:=0
	for i<10 {
		fmt.Println(i)
		i++
	}
}

• 最简单死循环

package main
import "fmt"
func main() {
	for{
		fmt.Println("根本停不下来")
	}
}

• 除了实现基本的循环结构以外,Go语言还实现了一种高级for循环for...range循环
  • for...range循环可以快速完成对字符串、数组、slice、map、channel遍历
• 格式

for 索引, 值 := range 被遍历数据{
}

package main
import "fmt"
func main() {
	// 1.定义一个数组
	arr := [3]int{1, 3, 5}
	// 2.快速遍历数组
	// i用于保存当前遍历到数组的索引
	// v用于保存当前遍历到数组的值
	for i, v := range arr{
		fmt.Println(i, v)
	}
}

---

四大跳转

• 和C语言一样,Go语言中也有四大跳转语句, 分别是return、break、continue、goto
• break语句
  • Go语言中的break语句可以用于,立即跳出switch、for和select
  • 但不同的是Go语言中的break语句可以指定标签

package main
import "fmt"
func main() {
	for i:=0; i<10; i++{
		if(i == 5){
			break // 跳出所在循环
		}
		fmt.Println(i)
	}
}

• 利用break跳转到指定标签
  • 标签必须在使用之前定义
  • 标签后面只能跟switch和循环语句, 不能插入其它语句
  • 跳转到标签之后switch和循环不会再次被执行

package main
import "fmt"
func main() {
outer:
	switch num:=2; num {
	case 1:
		fmt.Println(1)
	case 2:
		fmt.Println(2)
		break outer
	default:
		fmt.Println("other")
	}
	fmt.Println("come here")
}

package main
import "fmt"
func main() {
outer:
	for i:=0; i<5; i++{
		for j:=0; j<10; j++ {
			if (j == 5) {
				break outer// 跳出到指定标签
			}
			fmt.Println(j)
		}
	}
	fmt.Println("come here")
}

• continue语句
  • Go语言中的continue语句可以用于,立即进入下一次循环
  • 但不同的是Go语言中的continue语句可以指定标签

package main
import "fmt"
func main() {
	for i:=0; i<5; i++{
		if (i == 2) {
			continue
		}
		fmt.Println(i)
	}
}

• 利用continue 跳转到指定标签
  • 标签必须在使用之前定义
  • 标签后面只能跟循环语句, 不能插入其它语句
  • 对于单层循环和直接编写continue一样
  • 对于多层循环,相当于跳到最外层循环继续判断条件执行

package main
import "fmt"
func main() {
outer:
	for i:=0; i<5; i++{
		fmt.Println("i =", i) // 0 1 2 3 4
		for j:=0; j<10; j++ {
			if (j == 5) {
				continue outer// 跳出到指定标签
			}
		}
	}
	fmt.Println("come here")
}

• goto语句
  • Go语言中的goto和C语言中用法一样, 用于在同一个函数中瞎跳

package main
import "fmt"
func main() {
	num := 1
outer:
	if(num <= 10){
		fmt.Println(num)
		num++
		goto outer // 死循环
	}
	fmt.Println("come here")
}

package main
import "fmt"
func main() {
	num := 1
	if(num <= 10){
		fmt.Println(num)
		num++
		goto outer // 死循环
	}
outer:
	fmt.Println("come here")
}

• Go语言中的return语句和C语言一模一样,都是用于结束函数,将结果返回给调用者