第4章 流程控制

条件语句

package main
import (
    "fmt"
)
func main() {
    // 可以初始化子语句(只能有一个表达式)
    if a := 25; a > 20 {
        fmt.Println("a大于20")
    } else if a < 10 {
        fmt.Println("a小于10")
    } else {
        fmt.Println("10<=a<=20")
    }
}

选择语句

package main
import (
    "fmt"
)
func main() {
    grade := "B"
    marks := 90
    // 表达式switch写法1
    switch marks { // 也可以switch时初始化语句，写作 switch marks := 90; marks {
    case 90:
        grade = "A"
    case 80:
        grade = "B"
    case 60, 70:
        grade = "C"
    default:
        grade = "D"
    }
    fmt.Printf("grade: %s\n", grade)
    // 表达式switch写法2
    switch { // 也可以switch时初始化语句，写作 switch marks := 90; {
    case marks >= 90:
        grade = "A"
    case marks >= 80:
        grade = "B"
    case marks >= 70:
        grade = "C"
    case marks >= 60:
        grade = "D"
    default:
        grade = "E"
    }
    fmt.Printf("grade: %s\n", grade)
    // 表达式switch写法3-1
    switch {
    case grade == "A":
        fmt.Println("成绩优秀")
    case grade == "B":
        fmt.Println("表现良好")
    case grade == "C", grade == "D": // case 表达式可以有多个
        fmt.Println("再接再厉")
    default:
        fmt.Println("成绩不合格")
    }
    // 表达式switch写法3-2
    switch {
    case grade == "A":
        fmt.Println("成绩优秀")
    case grade == "B":
        fmt.Println("表现良好")
    case grade == "C":
        fallthrough // 同3-1，将两个表达式写一起
    case grade == "D":
        fmt.Println("再接再厉")
    default:
        fmt.Println("成绩不合格")
    }
    // 类型switch写法
    x = "1"
    switch i := x.(type) {
    case nil:
        fmt.Printf("i: %T\n", i)
    case int:
        fmt.Printf("i: %T\n", i)
    case float64:
        fmt.Printf("i: %T\n", i)
    case bool:
        fmt.Printf("i: %T\n", i)
    case string:
        fmt.Printf("i: %T\n", i)
    default:
        fmt.Printf("未知类型")
    }
    // select 语句
    a := make(chan int, 1024)
    b := make(chan int, 1024)
    for i := 0; i < 10; i++ {
        fmt.Printf("第%d次", i)
        a <- 1
        b <- 1
        select {
        case <-a:
            fmt.Println("from a")
        case <-b:
            fmt.Println("from b")
        }
    }
}
var x interface{} // 空接口

循环语句

package main
import (
    "fmt"
)
func main() {
    for a := 0; a < 5; a++ {
        fmt.Printf("a: %v\n", a)
    }
    a := 0
    b := 5
    for a < b {
        fmt.Printf("a: %v\n", a)
        a++
    }
    /*
        每一个for语句都可以使用一个特殊的range子语句，其作用类似迭代器可以轮询
        1. 数组或切片值中的每一个元素
        2. 字符串的每一个字符
        3. 字典值中的每个键值对
        4. 持续读取通道类型值中的元素
        具体参考代码块后的表格
    */
    str := "abcd"
    for i, char := range str {
        fmt.Printf("字符串第%d个字符的值为%d\n", i, char)
    }
    for _, char := range str { // 忽略第1个参数
        fmt.Println(char)
    }
    for i := range str { // 忽略第2个参数
        fmt.Println(i)
    }
    for range str { // 忽略所有参数，只执行下面的代码块
        fmt.Println("执行成功")
    }
}

延迟语句

package main
import (
    "fmt"
)
// 先输出 Hello 再输出world
func main() {
    defer fmt.Println("world")
    fmt.Println("Hello")
}
/*
    defer用于延迟调用指定函数
    defer只能出现在函数内部
    defer后的表达式必须是外部函数的调用
    defer语句全部执行完毕，defer所在函数才算真正结束执行，才会执行return语句
    defer延迟特点可以用来回收资源、清理收尾等工作。使用defer语句之后，不用纠结回收代码放哪里，反正都是最后执行
*/

package main
import (
    "fmt"
)
var i = 0
func print() {
    fmt.Println(i)
}
/*
输出
    5
    5
    5
    5
    5
解释
    defer在函数轮询之后执行，此时i为5
*/
func main() {
    for ; i < 5; i++ {
        defer print()
    }
}

package main
import (
    "fmt"
)
var i = 0
func print(i int) {
    fmt.Println(i)
}
/*
输出
    4
    3
    2
    1
    0
解释
    defer 压栈是携带i值  
*/
func main() {
    for ; i < 5; i++ {
        defer print(i)
    }
}

标签

package main
import (
    "fmt"
)
func main() {
LOOP1:
    for {
        x := 2
        switch {
        case x == 0:
            fmt.Println("A")
            break LOOP1
        case x == 1:
            fmt.Println("B")
            continue LOOP1
        case x == 2:
            fmt.Println("C")
            goto BREAK
        default:
            fmt.Println("C")
        }
    }
BREAK:
    println("break")
}