一、程序结构
说到流程控制，必须先看下 Go 语言的程序结构：
package main // 当前包名
import "fmt" // 导入程序中使用到的包
// 初始化函数
func init() {
// 初始化数据
}
// 程序入口主函数，且一个 package 只能有一个 main 函数
func main() {
fmt.Print("hello world") // 处理逻辑
}
程序的初始化和执行都起始于 main package 包，并且 main() 函数只能在 man 包中，一个项目里也只能有一个 main package。一个 go 程序文件中可以有一个 init()，一个项目中可以有 n 个 init() 函数。
程序包引入执行步骤：
程序文件执行步骤
Go 语言有统一的格式化方案，虽然限制了书写上的自由但统一了格式。Go 语言用换行作为语句的结束符，除非多条语句写在同一行，则用
;作为语句分割。
二、流程控制
1. if 条件语句
格式：
// if 语句格式
// else if 和 else 都是可选的，且 else if 可以有多个
// optionalStatement1 声明语句如（v := xx）中定义的变量其作用域只在 if ... else if ... else 范围内有效
if optionalStatement1; booleanExpression1 { // optionalStatement1：可选的声明语句，booleanExpression1：真假表达式，为真执行 block1 后跳出
block1
} else if optionalStatement2; booleanExpression2 { // optionalStatement1：可选的声明语句，booleanExpression1：真假表达式，为真且上面的条件都为假则执行 block2 后跳出
block2
} else { // 上面的条件都为假则执行 block3 后跳出
block3
}
示例：
package main
import "fmt"
func main() {
// 单个 if
if true {
fmt.Println("if 语句")
}
// if ... else ...
if false {
fmt.Println("不会输出")
} else {
fmt.Println("输出")
}
// if ... else if ... else ...
if 1 > 5 {
fmt.Println("条件假，不输出")
} else if 1 > 0 {
fmt.Println("条件真，输出")
} else {
fmt.Println("不会输出")
}
// if else if 更多
if v := 1; v > 5 {
fmt.Println("v==1 假，不输出")
} else if v++; v > 4 { // v == 2
fmt.Println("v==2 假，不输出2")
} else if v += 1; v == 3 { // v == 3
fmt.Println("v==3 真，输出3")
} else {
fmt.Println("上面语句有真不输出")
}
//fmt.Println(v) // 编译报错：undefined: v，v 的作用域只在 if ... else if ... else 范围内
}
2.switch 条件语句
格式：
// switch 语句格式
// 如果有 optionalStatement 则后面的 ‘;’ 是必须的，不论 optionalValue 是否存在
// case 下的 block 语句执行完后不会再往下个 case 走所以不用末尾加 break，如果要往下走则使用 fallthrough 语句
// 同 if 语句一样，optionalStatement 中声明的变量如（v := xx）其作用域也只在 switch 的范围内有效
switch optionalStatement; optionalValue { // optionalStatement：可选的声明语句，optionalValue ：可选得待比较值，如果未填写则默认为 true
case expression1: // 表达式 expression1 为真执行 block1
block1
...
case expressionN:
blockN
default: // default 可选的，上面都未匹配则执行 default 下的 blockD
blockD
}
示例：
package main
import "fmt"
func main() {
// switch 缺省表达式
switch {
case 1 < 0:
fmt.Println("不输出")
case 1 > 0:
fmt.Println("输出 1>0")
}
// switch 带声明语句
switch v := 1; { // 声明语句后必须跟';'
case v == 1:
fmt.Println("输出 v==1")
case v == 2:
fmt.Println("不输出")
default:
fmt.Println("不输出D")
}
//fmt.Println(v) // 编译报错：undefined: v，v 的作用域只在 switch 范围内
// switch with fallthrough
switch v := 1; v {
case 1:
fmt.Println("输出 v==1")
v++
fallthrough
case 2:
fmt.Println("输出 v==2")
fallthrough
case 3:
fmt.Println("不输出3")
default:
fmt.Println("不输出d")
}
}
3.select 条件语句
select 是用于通道 cahnnel 通信的选择语句，格式：
// select 语句，用于通道通信选择
select {
case sendOrReceive1: // 发送或接受通道信息
block
...
case sendOrReceiveN:
default:
blockD
}
示例：
package main
import "fmt"
func main() {
ch1 := make(chan int)
ch2 := make(chan int, 1)
ch3 := make(chan int, 2)
ch2 <- 2 // 往通道 ch2 中写入一个数据
select {
case i1 := <-ch1:
fmt.Println("读取 ch1 数据：", i1)
case i2 := <-ch2:
fmt.Println("读取 ch2 数据：", i2) // 输出：读取 ch2 数据： 2
case ch3 <- 3:
fmt.Println("写入 ch3 数据：3")
default:
fmt.Println("nothing")
}
}
4.for 循环语句
for 循环在 Go 语言中有多种格式选择：
// 无限循环
for {
block
}
// while 循环，Go 语言中没有单独的 while 循环，使用 for 循环代替
// booleanExpress 真假判断表达式
for booleanExpress {
block
}
// optionalPreStatement 可选的声明，存在时后面的 ';' 号必须，声明的变量作用域为 for 语句范围内
// booleanExpress 真假判断表达式
for optionalPreStatement; booleanExpress; optionalPostStatement {
block
}
// 使用 range 遍历数据
// 挨个字符遍历 aString 字符串
for index, char := range aString {
block
}
// 挨个字符遍历 aString 字符串
// 对于 UTF-8 的字符串，index 可能的值将是 0， 3， 5，...
for index := range aString {
block // char, size := utf8.DecodeRuneInString(aString[index:])
}
// 遍历数组或切片
for index, item := range anArrayOrSlice {
block
}
// 遍历数组或切片
for index := range anArrayOrSlice {
block // item := anArrayOrSlice[index]
}
// 遍历字典/映射
for key, value := range aMap {
block
}
// 遍历字典
for key := range aMap {
block // value := aMap[key]
}
// 遍历通道
for item := range aChannel {
block
}
示例：
package main
import (
"fmt"
"reflect"
)
func main() {
// 循环输出 1 到 10
// 类似 while 的循环输出
i := 1
for i <= 10 {
fmt.Println(i)
i++
}
// for 循环的不同表现
for i := 1; i <= 10; i++ {
fmt.Println(i)
}
var j int = 1
for j <= 10 { // 仅有一个真假表达式
fmt.Println(j)
j++
}
for j = 1; j <= 10; { // 有声明语句
fmt.Println(j)
j++
}
for ; j <= 10; j++ { // 没有声明语句
fmt.Println(j)
}
// 遍历字符串
str := "hello 世界"
// utf-8 遍历
for i := 0; i < len(str); i++ {
chr := str[i]
ctype := reflect.TypeOf(chr)
fmt.Printf("%s", ctype) // 输出：uint8
}
// unicode 遍历
for index, char := range str {
fmt.Println(index, char) // 输出字符起始位，及 Unicode 编码，如：6 19990
fmt.Printf("%q\n", char) // 格式化输出单个字符字面值，如：h
}
// 遍历数组、切片
arr := [5]int{1, 2, 3, 4, 5}
for i, v := range arr {
fmt.Printf("i: %d, v: %d\n", i, v)
}
sl := arr[2:]
for _, v := range sl { // 赋值给 '_' 的值会被忽略掉
fmt.Println(v)
}
// 遍历字典
var m = map[string]int{"a": 1, "b": 2}
for key, value := range m {
fmt.Printf("key: %s, value: %d\n", key, value)
}
for key := range m {
fmt.Println(key, m[key])
}
// 遍历通道
ch := make(chan int, 2)
ch <- 1
ch <- 2
fmt.Println(<-ch)
for v := range ch {
fmt.Println(v)
}
}
5.goto 跳转
顾名思义让程序跳到某个指定行重新执行。使用 goto 语句必须在当前函数内定义跳转标签，标签区分大小写。程序中一般不建议使用 goto 语句，过多的 goto 语句会打乱程序逻辑难以控制。
语法：
func funcName() {
... //
GotoTag: // goto 跳转标签
...
goto GotoTag // 跳转到 GotoTag 行重新执行
...
}
实例：
package main
import "fmt"
func main() {
i := 0
LOOPTAG:
for i < 10 {
i++
if i == 5 { // i = 5 时跳出 for 循环，不会打印 5
goto LOOPTAG
}
fmt.Println(i)
}
// 递减输出 i 到 0
TAG:
fmt.Println(i)
i--
if i > 0 {
goto TAG
}
fmt.Println("end")
}
