Go流控制（一）

相对比java，go的流控制比较精简。
if...else...

func main() {
    x := 3
    if x > 5 {
        println("a")
    } else if x < 5 && x > 0 {
        println("b")
    } else {
        println("z")
    }
}

对初始化语句的支持

func main() {
    x := 10

    var xinit = func () {
        x = x -10
    }

    if xinit(); x == 0 {    //优先执行xint函数
        println("a")
    }

    if a, b := x+1, x+10; a < b {  //定义一个或多个局部变量(也可以是函数返回值)
        println(a)
    } else {
        println(b)
    }
}

switch

func main() {
    a, b, c, x := 1, 2, 3, 2

    switch x {             //将x与case条件匹配
    case a, b:             //多个匹配条件命中其一即可
        println("a | b")
    case c:                //单个匹配
        println("c")
    case 4:                //常量
        println("d")
    default:
        println("2")
    }
}

输出：

a | b

switch同样支持初始化语句，按从上到下、从左到右顺序匹配case执行。只有全部匹配失败时，才会执行default块。

func main() {
    switch x := 5; x {
    default:
        x += 100
        println(x)
    case 5:
        x += 50
        println(x)
    }
}

输出：

无须显式执行break语句，case执行完毕自动中断。如须贯通后续case，须执行fallthrough，但不再匹配后续条件表达式。

func main() {
    switch x := 5; x {
    default:
        println(x)
    case 5:
        x += 50
        println(x)
        fallthrough      //继续执行下一case。但不再匹配条件表达式
    case 6:
        x += 10
        println(x)
    }
}

输出：

55
65

for

func main() {
    for i := 0;i < 3;i++ {
        println(i)
    }
    
    x := 1
    for x < 10 {  //类似while x < 10
        x ++
        println(x)
    }
    for {      //类似于while true {}
        break
    }
}

初始化语句仅被执行一次。条件表达式中如有函数调用，须确认是否会重复执行。

func count() int {
    print("count.")
    return 3
}
func main() {
    for i, c := 0, count(); i < c; i++ { //初始化语句的count函数仅执行一次
        println("a", i)
    }
    c := 0
    for c < count() {           //条件表达式中的count重复执行
        println("b", c)
        c++
    }
}

输出：

count.a 0
a 1
a 2
count.b 0
count.b 1
count.b 2
count.

for...range
可用for...range完成数据迭代，支持字符串、数组、数组指针、切片、字典、通道类型，返回索引、键值数据。

func main() {
    data := [3]string{"a","b","c"}
    for i, s := range data {
        println(i, s)
    }
}

输出：

0 a
1 b
2 c

允许返回单值，或用"_"忽略

func main() {
    data := [3]string{"a","b","c"}
    for i := range data {  //只返回value
        println(i, data[i])
    }
    for _, s := range data { //忽略索引
        println(s)
    }
    for range data {  //仅迭代不返回
    }
}

输出：

0 a
1 b
2 c
a
b
c

注意，range会复制目标数据。受直接影响的是数组，可改用数组指针或切片类型。

func main() {
    data := [3]int{10, 20, 30}
    for i, x := range data {  //从data复制品中取值
        if i == 0 {
            data[0] += 100
            data[1] += 200
            data[2] += 300
        }
        fmt.Printf("x: %d, data: %d\n", x, data[i])
    }

    for i, x := range data[:] { //仅复制slice, 不包括底层array
        if i == 0 {
            data[0] += 100
            data[1] += 200
            data[2] += 300
        }
        fmt.Printf("x: %d, data: %d\n", x, data[i])
    }
}

输出：

x: 10, data: 110
x: 20, data: 220
x: 30, data: 330

x: 110, data: 210
x: 420, data: 420
x: 630, data: 630

goto，continue，break
goto定点跳转

func main() {
    for i := 0; i < 3; i++ {
        println(i)
        if i > 1 {
            goto exit
        }
    }
    exit:
        println("exit.")
}

输出：

0
1
2
exit.

goto不能跳转到其他函数，或内层代码块内。
和goto定点跳转不同，break、continue用于中断代码块执行。

break：用于switch、for、select语句，终止整个语句块执行。
continue：仅用于for循环，终止后续逻辑，立即进入下一轮循环。