第三章：控制结构与函数

3.1 条件语句

if语句

package main
​
import "fmt"
​
func main() {
    score := 85
    
    // 基本if
    if score >= 60 {
        fmt.Println("及格")
    }
    
    // if-else
    if score >= 90 {
        fmt.Println("优秀")
    } else if score >= 80 {
        fmt.Println("良好")
    } else if score >= 60 {
        fmt.Println("及格")
    } else {
        fmt.Println("不及格")
    }
    
    // if with statement（声明语句）
    if age := 20; age >= 18 {
        fmt.Println("成年人")
    }
    // age在这里不可用
}

switch语句

package main
​
import "fmt"
​
func main() {
    day := 3
    
    // 基本switch
    switch day {
    case 1:
        fmt.Println("星期一")
    case 2:
        fmt.Println("星期二")
    case 3:
        fmt.Println("星期三")
    case 4, 5:
        fmt.Println("周四或周五")
    default:
        fmt.Println("周末")
    }
    
    // switch with expression
    score := 85
    switch {
    case score >= 90:
        fmt.Println("A")
    case score >= 80:
        fmt.Println("B")
    case score >= 60:
        fmt.Println("C")
    default:
        fmt.Println("D")
    }
    
    // switch with statement
    switch num := 10; {
    case num > 0:
        fmt.Println("正数")
    case num < 0:
        fmt.Println("负数")
    default:
        fmt.Println("零")
    }
}

3.2 循环语句

for循环

package main
​
import "fmt"
​
func main() {
    // 基本for循环
    for i := 0; i < 5; i++ {
        fmt.Println(i)
    }
    
    // 条件for（类似while）
    n := 0
    for n < 5 {
        fmt.Println(n)
        n++
    }
    
    // 无限循环
    count := 0
    for {
        if count >= 5 {
            break
        }
        fmt.Println(count)
        count++
    }
    
    // continue和break
    for i := 0; i < 10; i++ {
        if i%2 == 0 {
            continue  // 跳过偶数
        }
        if i > 7 {
            break     // 大于7时退出
        }
        fmt.Println(i)  // 输出1, 3, 5, 7
    }
    
    // 遍历切片
    nums := []int{10, 20, 30, 40}
    for index, value := range nums {
        fmt.Printf("索引:%d 值:%d\n", index, value)
    }
    
    // 遍历map
    scores := map[string]int{"张三": 90, "李四": 85}
    for name, score := range scores {
        fmt.Printf("%s: %d\n", name, score)
    }
    
    // 只遍历key
    for name := range scores {
        fmt.Println(name)
    }
    
    // 忽略index
    for _, value := range nums {
        fmt.Println(value)
    }
}

3.3 函数基础

函数声明

package main
​
import "fmt"
​
// 无参数无返回值
func sayHello() {
    fmt.Println("Hello!")
}
​
// 有参数无返回值
func greet(name string) {
    fmt.Printf("Hello, %s!\n", name)
}
​
// 多参数
func add(a int, b int) int {
    return a + b
}
​
// 同类型参数简写
func multiply(a, b int) int {
    return a * b
}
​
// 多返回值
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("除数不能为0")
    }
    return a / b, nil
}
​
// 命名返回值
func rectangle(width, height float64) (area, perimeter float64) {
    area = width * height
    perimeter = 2 * (width + height)
    return  // 裸return，自动返回命名值
}
​
func main() {
    sayHello()
    greet("张三")
    
    sum := add(10, 20)
    fmt.Println("和:", sum)
    
    product := multiply(5, 6)
    fmt.Println("积:", product)
    
    result, err := divide(10, 2)
    if err != nil {
        fmt.Println("错误:", err)
    } else {
        fmt.Println("结果:", result)
    }
    
    a, p := rectangle(5, 3)
    fmt.Printf("面积:%.2f 周长:%.2f\n", a, p)
}

变长参数

package main
​
import "fmt"
​
// 变长参数函数
func sum(nums ...int) int {
    total := 0
    for _, num := range nums {
        total += num
    }
    return total
}
​
// 变长参数 + 普通参数
func printf(format string, args ...interface{}) {
    fmt.Printf(format, args...)
}
​
func main() {
    fmt.Println(sum(1, 2, 3))
    fmt.Println(sum(1, 2, 3, 4, 5))
    
    // 传递切片
    nums := []int{1, 2, 3, 4}
    fmt.Println(sum(nums...))
    
    printf("姓名:%s 年龄:%d\n", "张三", 25)
}

函数作为参数和返回值

package main
​
import "fmt"
​
// 函数类型
type Calculator func(int, int) int
​
// 函数作为参数
func calculate(a, b int, op Calculator) int {
    return op(a, b)
}
​
// 函数作为返回值
func getOperator(op string) Calculator {
    switch op {
    case "+":
        return func(a, b int) int { return a + b }
    case "-":
        return func(a, b int) int { return a - b }
    case "*":
        return func(a, b int) int { return a * b }
    default:
        return nil
    }
}
​
// 闭包
func makeMultiplier(factor int) func(int) int {
    return func(x int) int {
        return x * factor
    }
}
​
func main() {
    // 函数作为参数
    add := func(a, b int) int { return a + b }
    result := calculate(10, 20, add)
    fmt.Println(result)
    
    // 函数作为返回值
    multiply := getOperator("*")
    fmt.Println(multiply(5, 6))
    
    // 闭包
    double := makeMultiplier(2)
    triple := makeMultiplier(3)
    fmt.Println(double(5))  // 10
    fmt.Println(triple(5))  // 15
}

3.4 defer语句

package main
​
import "fmt"
​
func main() {
    // defer后进先出
    defer fmt.Println("1")
    defer fmt.Println("2")
    defer fmt.Println("3")
    fmt.Println("执行中...")
    // 输出顺序：执行中... -> 3 -> 2 -> 1
}
​
// defer常用于资源清理
func readFile() {
    file, err := os.Open("file.txt")
    if err != nil {
        return
    }
    defer file.Close()  // 确保文件关闭
    
    // 读取文件...
}
​
// defer与return
func deferAndReturn() int {
    result := 0
    defer func() {
        result++  // 在return之后执行
        fmt.Println("defer:", result)
    }()
    return result  // 返回0
}

3.5 panic和recover

package main
​
import "fmt"
​
func mayPanic() {
    panic("出错了！")
}
​
func safeCall() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("恢复:", r)
        }
    }()
    
    mayPanic()
    fmt.Println("这行不会执行")
}
​
func main() {
    safeCall()
    fmt.Println("程序继续执行")
}

3.6 init函数

package main
​
import "fmt"
​
// 在main之前自动执行
func init() {
    fmt.Println("init 1")
}
​
func init() {
    fmt.Println("init 2")
}
​
func main() {
    fmt.Println("main")
}
// 输出顺序：init 1 -> init 2 -> main