Go语言编程笔记3：控制流

图源：2zyyyyy.github.io

一般来说，不同的编程语言之间控制流语句的差别应该是很小的，但Go语言的控制流语句有很多不同之处，值得单独进行讨论。

if

除了和其它语言类似的写法以外，Go语言可以在if语句的条件中添加赋值语句：

package main
​
import "fmt"
​
func main() {
    if a := 6; a < 10 {
        fmt.Println("a<10")
    }
}

当然上边这段示例的写法是没必要的，更常见的是通过函数调用获取结果后进行判断：

package main
​
import (
    "fmt"
    "log"
    "strconv"
)
​
func main() {
    checkStringNumber("12")
    checkStringNumber("2.5")
    checkStringNumber("lalala")
}
​
func checkStringNumber(strA string) {
    if floatA, err := strconv.ParseFloat(strA, 64); err != nil {
        log.Fatal(err)
    } else if floatA > 10 {
        fmt.Println("a>10")
    } else {
        fmt.Println("a<=10")
    }
}
​
// a>10
// a<=10
// 2021/11/07 15:38:50 strconv.ParseFloat: parsing "lalala": invalid syntax

当然这种方式只是给你提供了一种选择，并非必须，不过这么做可能带来的好处就是，将通过函数调用的返回值的使用范围局限到一个if语句的作用域内，而不会污染外部的函数作用域。如果你遇到一些变量命名冲突的问题可以尝试用这种方式解决。

此外，Go语言对一些格式有严格要求，比如常见的if...else写法：

package main
​
import "fmt"
​
func main() {
    if 1 < 5 {
        fmt.Println("1<5")
    }
    else{
        fmt.Println("1>=5")
    }
}

在Go语言中是不允许的，因为Go要求else必须要和if块的}符号在同一行：

package main
​
import "fmt"
​
func main() {
    if 1 < 5 {
        fmt.Println("1<5")
    } else {
        fmt.Println("1>=5")
    }
}

怎么说呢，我一直都用的不允许的那种书写风格...我只能说，Go语言的作者大概是个强迫症吧。

顺带一提，Go语言中是可以给if语句中的条件表达式加上()的，但没必要，因为官方的格式化工具会在格式化代码时强制将不必要的()删除，你大概会写了个寂寞。

for

Go语言中只有for语句用于循环，没有while语句。此外for也仅有一种形式，即最经典的for 循环变量初始化;循环条件;循环变量步进。

这里展示一个实际例子：

package main
​
import "fmt"
​
func main() {
    for i := 0; i < 10; i++ {
        fmt.Printf("%d ", i)
    }
    fmt.Println()
}
​
// 0 1 2 3 4 5 6 7 8 9

特别的，可以将循环变量初始化和步进语句省略，在这种情况下for循环更像是其它语言中的while语句：

package main
​
import "fmt"
​
func main() {
    i := 0
    for i < 10 {
        fmt.Printf("%d ", i)
        i++
    }
    fmt.Println()
}
​
// 0 1 2 3 4 5 6 7 8 9

此时i<10左右两侧的;写不写都一样，格式化工具会自动删除，所以最好还是别写。

甚至可以完全删除for所有的三个表达式：

package main
​
import "fmt"
​
func main() {
    i := 0
    for {
        if i >= 10 {
            break
        }
        fmt.Printf("%d ", i)
        i++
    }
    fmt.Println()
}
​
// 0 1 2 3 4 5 6 7 8 9

此时的for语句事实上就是一个无限循环语句，除非使用break跳出，否则会一直循环下去。

其它比较常见的用法还有结合range关键字来迭代数组或切片：

package main
​
import "fmt"
​
func main() {
    numbers := []int{1, 2, 3, 4, 5, 6}
    for index, value := range numbers {
        fmt.Printf("numbers[%d]=%d\n", index, value)
    }
}
​
// numbers[0]=1
// numbers[1]=2
// numbers[2]=3
// numbers[3]=4
// numbers[4]=5
// numbers[5]=6

通道也可以使用这种方式来迭代，关于通道，会在后边介绍。

for语句的作用域问题也是个会容易忽视的问题，该内容已经在之前Go语言编程笔记2：变量中讨论过了，这里不再赘述。

switch

表面上看Go语言的switch语句与其它语言类似，其实有很大的不同：

package main
​
import "fmt"
​
func main() {
    login("lalala")
    login("root")
    login("apple")
}
​
func login(name string) {
    switch name {
    case "apple":
        fmt.Println("welcome")
    case "root":
        fmt.Println("don't permit use root account login")
    default:
        fmt.Println("it's a unregistry account")
    }
}
​
// it's a unregistry account
// don't permit use root account login
// welcome

看上去似乎除了没有使用break以外和其它语言的switch语句差别不大，但其实有很大差别。

一般性的switch语句的执行流程是依次匹配所有的case条件，如果满足就执行相应的case块，执行过程中如果有break语句就跳出switch，如果没有，在结束case块后会继续switch的逻辑向下匹配。

但Go语言中的switch不会，它会像自带break那样，一旦匹配到某个case条件，执行完相应的case块，就会结束整个switch语句。

此外，我们依然是可以在switch中显式地执行break的：

package main
​
import "fmt"
​
func main() {
    login("lalala")
    login("root")
    login("apple")
}
​
func login(name string) {
    switch name {
    case "apple":
        break
        fmt.Println("welcome")
    case "root":
        fmt.Println("don't permit use root account login")
    default:
        fmt.Println("it's a unregistry account")
    }
}
​
// it's a unregistry account
// don't permit use root account login

Go语言的switch语法中还有一个奇怪的关键字fallthrough：

package main
​
import "fmt"
​
func main() {
    login("lalala")
    login("root")
    login("apple")
}
​
func login(name string) {
    switch name {
    case "apple":
        fmt.Println("welcome")
        fallthrough
    case "root":
        fmt.Println("don't permit use root account login")
    default:
        fmt.Println("it's a unregistry account")
    }
}
​
// it's a unregistry account
// don't permit use root account login
// welcome
// don't permit use root account login

如果在某个case块的结尾使用fallthrough，程序会自动跳转到下一个case块中执行，无论下一个case块的匹配条件是什么。我并不清楚这个关键字在实际工作中有什么使用场景，所以这里不过多讨论。

除了一般性的利用switch进行值匹配外，switch还可以检测变量的类型：

package main
​
import "fmt"
​
func main() {
    checkType("hello")
    checkType("1")
    checkType(1)
    checkType(2.5)
}
​
func checkType(variable interface{}) {
    var varForm string
    switch variable.(type) {
    case int:
        varForm = "int"
    case float64, float32:
        varForm = "float"
    case string:
        varForm = "string"
    default:
        varForm = "not known"
    }
    fmt.Printf("%v 's type is %s\n", variable, varForm)
}
​
// hello 's type is string
// 1 's type is string
// 1 's type is int
// 2.5 's type is float

特别的，如果用switch匹配多个接口类型，是有可能同时满足多个接口的，此时应当遵循“先精细后粗略”的顺序排布case条件，这部分内容会在后续接口部分的笔记介绍。

往期内容

• Go语言编程笔记2：变量

• Go语言编程笔记1：Hello World