跳转至

Go 流程控制语句

约 357 个字 126 行代码 预计阅读时间 3 分钟

唯一的循环：for

1
2
3
for a; b; c {
    ...
}
  • a：初始化语句（可选）
  • b：条件表达式
  • c：后置语句（可选）
  • 大括号必需

仅有条件表达式时可以省去分号，类似于其他语言的 while。

1
2
3
4
5
6
7
for b {
    ...
}
// 等价于
for ; b; {
    ...
}

死循环：

1
2
3
for {
    ...
}

遍历

1
2
3
for i, v := range Slice {
    ...
}

range形式可遍历切片/映射。

迭代切片时，每次迭代都会返回两个值：

  • 下标
  • 下标对应元素的一份副本

可将下标或值赋予 _ 来忽略它：

1
2
for i, _ := range Slice
for _, v := range Slice

若只需要索引，忽略第二个变量：

1
2
3
for i := range Slice
// 等价于
for i, _ := range Slice

if

基本形式

1
2
3
if b {
    ...
}

大括号必需。

else

1
2
3
4
5
if b {
    ....
} else {
    ....
}

else if

1
2
3
4
5
6
7
8
if b1 {
    ...
} else if b2 {
    ...
}
} else {
    ...
}

可在条件表达式前实现一个简单的语句

1
2
3
4
5
if a; b {
    ...
} else {
   ...
}

仅作用于 if 和对应的 else 内。

练习：牛顿法

 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
package main
import (
    "fmt"
    "math"
)
func abs(x float64) float64 {
    if x < 0 {
        return -x
    } else {
        return x
    }
}
func Sqrt(x float64) float64 {
    z := x/2
    for i := float64(-x); abs(i - z) > 0.00000000001; {
        i = z
        z -= (z * z - x) / (2 * z)
        fmt.Println(">> ", z)
    }
    return z
}
func main() {
    t := 252465.0
    fmt.Println(Sqrt(t))
    fmt.Println(math.Sqrt(t))
}

来源：https://tour.go-zh.org/flowcontrol/8

switch

1
2
3
4
5
6
7
8
switch b {
    case b1:
        ...
    case b2:
        ...
    default:
        ...
}

基本形式

只运行选定的 case，后面默认 break，除非以 fallthrough 语句结束。

1
2
3
4
5
6
7
8
switch a; b {
    case b1:
        ...
    case b2:
        ...
    default:
        ...
}

可在条件表达式前实现简单语句。

 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
package main
import (
    "fmt"
)
var tv int = 0
func test(x int) int{
    tv = x
    return x
}
func main() {
    i := 2
    k := 0
    switch i {
        case 0:
        k = 1
        case test(1):
        k = 2
        case 2:
        k = 3
        case test(3):
        k = 12
        default:
        k = 4
    }
    fmt.Println(tv, i, k)
}

1
1 2 3

case 语句从上到下顺次执行，直到匹配成功时停止。

当 case 的值为函数时，在匹配值之前的 case 中的函数会被调用！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
switch {
    case b1:
        ...
    case b2:
        ...
    default:
        ...
}
//等价于
if b1 {
    ...
} else if b2 {
    ...
} else {
    ...
}

switch可以无条件，类似于if-else。

defer

在函数前使用，让函数推迟到外层函数返回之后执行。

推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用。

推迟的函数调用存放在栈中，返回后以后进先出的顺序调用。