Go基础语法：流程控制

4 流程控制和运算符

Go 语言中常用的流程控制有 if 和 for。而 switch 和 goto 主要是为了简化代码、降低重复代码而生的结构，属于扩展类的流程控制。

4.1 if 语句

4.1.1 if 语句的基本格式

if 表达式1 {
	分支1
} else if 表达式2 {
	分支2
} else {
	分支3
}

4.1.2 if 的特殊写法

// 此处声明的变量 score 只在 if 语句中有效
if score := 65; score >= 90 {
	fmt.Println("A")
} else if score > 75 {
	fmt.Println("B")
} else {
	fmt.Println("C")
}

4.2 for 语句

go 语言中所有的循环类型都可以使用 for 关键字来完成。

4.2.1 for 基本格式

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

for i := 0; i < 10; i++ {
	fmt.Println(i)
}

4.2.2 省略初始值的样式

初始语句可以被省略，但初始语句后的分号不能被省略

i := 0
for ; i < 5; i++ {
	fmt.Println(i)
}

4.2.3 省略初始语句和结束语句

i := 0
for i < 5 {
	fmt.Println(i)
	i++
}

4.2.4 死循环

for {
	// 循环语句
}

4.2.5 for range

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

• 数组、切片、字符串返回索引和值
• map 返回键和值
• 通道（channel）只返回通道中的值

package main

import (
	"fmt"
)

func main() {
	str := "hello,中国"
	for index, value := range str {
		fmt.Printf("%d %c\n", index, value)
	}
}

输出结果如下：

0 h
1 e
2 l
3 l
4 o
5 ,
6 中
9 国

上述示例中，由于中和国占3个字节，所以，国的索引从 9 开始。

4.2.6 跳出 for 循环——break

package main

import (
	"fmt"
)

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

输出结果为：

0
1
2
3
4
循环结束

4.2.7 跳过某次循环——continue

package main

import (
	"fmt"
)

func main() {
	for i := 0; i < 10; i++ {
		if i == 5 {
			// 跳出 for 循环
			continue
		}
		fmt.Println(i)
	}
	fmt.Println("循环结束")
}

输出结果为：

0
1
2
3
4
6
7
8
9
循环结束

4.3 switch 语句

4.3.1 switch 基本写法

package main

import (
	"fmt"
)

func main() {
	finger := 3
	switch finger {
	case 1:
		fmt.Println("大拇指")
	case 2:
		fmt.Println("食指")
	case 3:
		fmt.Println("中指")
	case 4:
		fmt.Println("无名指")
	case 5:
		fmt.Println("小拇指")
	default:
		fmt.Println("输入无效")
	}
}

4.3.2 一个分支有多个值

package main

import (
	"fmt"
)

func main() {

	// 声明仅在 switch 中有效的变量 n
	switch n := 3; n {
	case 1, 3, 5, 7, 9:
		fmt.Println("奇数")
	case 2, 4, 6, 8:
		fmt.Println("偶数")
	default:
		fmt.Println("其他数值")
	}
}

4.3.3 case 语句可以是表达式

package main

import (
	"fmt"
)

func main() {

	age := 3
	switch {
	case age < 18:
		fmt.Println("未成年人")
	case age > 50:
		fmt.Println("老年人")
	default:
		fmt.Println("中年人")
	}
}

4.3.3 case 语句穿透–fallthrough

package main

import (
	"fmt"
)

func main() {
	s := "a"

	switch {
	case s == "a":
		fmt.Println("a")
		fallthrough
	case s == "b":
		fmt.Println("b")
	case s == "c":
		fmt.Println("c")
	default:
		fmt.Println("其他字符")
	}
}

输出结果：

a
b

因为语句中使用了 fallthrough，所以打印完 a 之后还会打印一个 b

4.4 goto

goto 语句通过标签进行代码间的无条件跳转。goto 常用于快速跳出循环、避免重复退出。

4.4.1 快速跳出双层循环

• 未使用 goto 语句时跳出双层循环的写法

package main

import (
	"fmt"
)

func main() {
	var breakFlag bool
	for i := 0; i < 10; i++ {
		for j := 0; j < 5; j++ {
			if j == 3 {
				breakFlag = true
				break
			}
			fmt.Printf("内存循环的值 %d", j)
		}
		if breakFlag {
			break
		}
		fmt.Printf("外层循环的值 %d", i)
	}
}

• 使用 goto 后的写法

package main

import (
	"fmt"
)

func main() {

	for i := 0; i < 10; i++ {
		for j := 0; j < 5; j++ {
			if j == 3 {
				goto myBreakTag
			}
			fmt.Printf("内存循环的值 %d \n", j)
		}
		fmt.Printf("外层循环的值 %d \n", i)
	}

myBreakTag:
	fmt.Println("使用 goto 快速跳出双层循环，并指向自定义的 TAG")
}

运行结果：

内存循环的值 0 
内存循环的值 1 
内存循环的值 2 
使用 goto 快速跳出双层循环，并指向自定义的 TAG