接下来学习go语言的基本流程控制，包含if、switch、for、defer四个关键字。
if
go语言与其他语言的一个不同之处，就是控制语句不需要额外的括号包裹，if语句的使用如下
1
2
3
4
5
6
7
8
9
10
11
|
if x < 0 {
return "hi,i'm work"
}
if x > 0 {
return "a"
} else if x < 0 {
return "b"
} else {
return "c"
}
|
上面的用例介绍基础用法，go的独特之处还有一点，就是可以在if中插入简单的表达式
1
2
3
4
5
6
|
func pow(x, n, lim float64) float64 {
if v := math.Pow(x, n); v < lim {
return v
}
return lim
}
|
当然，上面的用法中v的作用于就仅限制于if语句内，想要在if语句外访问，则还是需要定义在if语句外部。同理，if语句内部的变量需要传递下去，则需要在if语句之前声明好变量。
switch
go语言中switch的语法逻辑是从上到下，每个分支判断，分支判断为true时则执行该分支，用法和其他语言差不多，不过go语言中，每种case情况不需要单独的写break，go默认只执行单个case下的逻辑，下面的举例可以查看基础用法，此外当多个分支存在同一结果时，可以将多种匹配数值逗号拼接，写在同一行进行简化处理：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
switch a {
case "a":
fmt.Println("a")
case "b":
fmt.Println("b")
case "c","d","e":
fmt.Println("c-e")
default:
fmt.Printf("%s.\n", os)
}
switch {
case a == "a":
fmt.Println("a")
case a == "b":
fmt.Println("b")
default:
fmt.Printf("%s.\n", os)
}
switch os := runtime.GOOS; os {
case "darwin":
fmt.Println("OS X.")
case "linux":
fmt.Println("Linux.")
default:
fmt.Printf("%s.\n", os)
}
|
从上面的例子可以看到和if类似，switch也允许使用短表达式。此外，go语言中switch结合类型断言以及channel还有其独特的用法，这里简单举例，具体情况之后再详细讨论。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
switch i:= x.(type) {
case nil:
fmt.Println("type is nil")
case int:
fmt.Println("type is int")
case bool:
fmt.Println("type is bool")
case string:
fmt.Println("type is string")
case func(int) int:
fmt.Println("type is func(int)int")
default:
fmt.Println("type others")
}
|
使用switch最后还有一些简单的控制流转需要说明，即break和fallthrough两个关键字，break可以在当个case下立刻终止执行，跳出switch逻辑，fallthrough的作用则是继续往下执行。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
switch {
case false:
fmt.Println("1、case 条件语句为 false")
fallthrough
case true:
fmt.Println("2、case 条件语句为 true")
fallthrough
case false:
fmt.Println("3、case 条件语句为 false")
fallthrough
case true:
fmt.Println("4、case 条件语句为 true")
case false:
fmt.Println("5、case 条件语句为 false")
fallthrough
default:
fmt.Println("6、默认 case")
}
// 最终输出
// case 条件语句为 true
// case 条件语句为 false
// case 条件语句为 true
|
for
for语句作为go语言的唯一循环关键字，用法和其他语言差不多，格式上可以划分三个部分，第一是初始化部分，第二是循环终止判断部分，第三是迭代推进部分。此外，for也可以只写终止条件或者不写任何条件，通过break跳出循环。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
for i := 0; i < 10; i++ {
sum += i
}
for i,j := 0,0; i < 10; i++ {
sum += i
j++
}
for i<20 {
i++
}
for {
if i>20 {
break
}
}
|
for语句除了上面基础用法外，还有一种比较常用的方法，即配合range使用。
1
2
3
4
5
6
7
8
|
lis := []int{1,2,3}
for idx,val := range lis{
fmt.Println(idx,val)
}
m := map[int]string{1:"a",2:"b"}
for key,val := range m {
fmt.Println(key,val)
}
|
使用for range的操作时需要注意，go语言里面的值拷贝的原因，如果我们在遍历指针数据，并利用了迭代变量地址时，需要注意迭代变量最后指向数据最后一个值的情况。
1
2
3
4
5
6
7
8
9
10
11
12
|
type A struct {
name string
}
arr := []A{
A{"a"},
A{"b"},
}
var res []*A
for _, v := range arr {
res = append(res, &v)
}
|
上面的代码可以看到，我们在res里面存储的是v的地址，而v在循环结束后指向最后一个值，因此res里面存储的都是A{"b"}数据。
defer
defer是go语言的特色关键字，其作用是在函数中定义额外的执行逻辑，即函数执行完后还需要执行defer定义的语句。当一个函数内部有多个defer语句是，则执行的顺序是按照defer语句从上到下，先进后出的栈式顺序执行。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
func main() {
fmt.Println("counting")
for i := 0; i < 3; i++ {
defer fmt.Println(i)
}
fmt.Println("done")
}
/* 输出结果
counting
done
2
1
0
*/
|
参考