运算符、流程控制与作用域

一、学习目标

二、知识讲解

1.1 Go 运算符与优先级

Go 的运算符分为算术、比较、逻辑、位运算和赋值运算符。理解运算符的优先级对于编写无歧义的表达式至关重要。

1. 算术与比较运算符 包括 +, -, *, /, % 以及 ==, !=, <, <=, >, >=。这些与其他语言基本一致。

2. 逻辑运算符 包括 &&（逻辑与）、||（逻辑或）。Go 支持短路求值（Short-circuit evaluation）： - a && b：若 a 为 false，则 b 不会被求值。 - a || b：若 a 为 true，则 b 不会被求值。 这在防止空指针解引用或无效参数检查中非常有用。

3. 位运算符 Go 支持对整数类型进行位操作： - &（按位与）：a & b - |（按位或）：a | b - ^（按位异或/取反）：a ^ b 是异或；^a 是一元取反。 - &^（AND NOT）：a &^ b，将 b 中为 1 的位从 a 中清除。这是一个 Go 特有的运算符，常用于掩码操作。 - <<, >>（左移/右移）

4. 优先级 Go 的运算符优先级从高到低如下（同优先级从左到右结合，右移除外）：

注意：一元运算符 +, -, !, ^, *, &, <- 具有最高优先级（优先级 6）。++ 和 -- 是语句而非运算符，没有优先级。

1.2 if 带初始化语句

Go 的 if 语句支持一个可选的初始化语句，该语句在 if 执行前运行，且其作用域仅限于 if 块内部。这有助于减少变量污染，使代码更紧凑。

if err := doSomething(); err != nil {
    // err 仅在此作用域有效
    log.Fatal(err)
}
// err 在此处不可见

1.3 for 的四种形态

Go 只有一种循环结构：for。它可以通过不同的形式模拟其他语言的 while、do-while 和 foreach。

1. 标准循环（C 风格） go for init; condition; post { } // 例如： for i := 0; i < 5; i++ { }
2. 条件循环（While 风格） go for condition { } // 例如： for i < 5 { i++ }
3. 无限循环 go for { } // 通常配合 break 使用
4. for range 循环 用于遍历数组、切片、字符串、Map、Channel 以及 Go 1.22+ 的整数。 go for index, value := range slice { }
5. do-while 模拟 Go 没有直接的 do-while，但可以通过以下方式模拟： go for { // 循环体 if !condition { break } }

Go 1.22 变更：从 Go 1.22 开始（依据模块 go.mod 的 go 指令生效），for（3 段式与 for range）每次迭代都会创建新的循环变量。这意味着在 goroutine 中捕获循环变量不再需要额外的闭包技巧，每个 goroutine 将获得独立的变量副本。

1.4 switch 无需 break 与 type switch

Go 的 switch 语句非常强大： 1. 无需 break：每个 case 执行完毕后自动退出，除非使用 fallthrough。 2. fallthrough：会无条件执行下一个 case 的语句体，容易掩盖意图，仅在确需穿透时使用。 3. 类型不匹配检查：switch 后的表达式类型必须与 case 后的类型兼容（或可转换）。 4. Type Switch：用于判断接口的动态类型。 go switch x.(type) { case int: // ... case string: // ... }

1.5 作用域与变量遮蔽

作用域决定了标识符（变量、函数名等）在代码中的可见范围。Go 的作用域包括： - Universe 作用域：预声明标识符（如 int, nil, true）。 - 包级作用域：在 package 声明下、函数外声明的标识符，同包所有文件可见。 - 文件级作用域：import 引入的包名，仅在当前文件可见。 - 块级作用域：由 {} 包围的代码块，如 if, for, switch 内部。

遮蔽（Shadowing）：当内部作用域声明了一个与外部作用域同名的变量时，内部变量会“遮蔽”外部变量。在内部作用域中，访问该名称将指向内部变量。这可能导致 Bug，因为外部变量的值并未被修改。

三、示例代码

示例 1：运算符与 for range 基础

本示例演示位运算符（包括 &^ 和一元 ^）、逻辑短路以及 for range 的基本用法。

package main

import "fmt"

func main() {
    a := uint8(12) // 00001100
    b := uint8(10) // 00001010

    // 位运算演示
    // ^a 是一元取反，uint8 取反后为 255 - 12 = 243 (11110011)
    fmt.Printf("^a    = %08b (%d)\n", ^a, ^a)

    // a &^ b 是 AND NOT，清除 b 中为 1 的位：00001100 &^ 00001010 = 00000100
    fmt.Printf("a &^ b = %08b (%d)\n", a&^b, a&^b)

    // 逻辑短路演示
    // 如果 a > 10 为 false，则 a < 20 不会被求值
    if a > 10 && a < 20 {
        fmt.Println("Short-circuit OR worked")
    } else {
        fmt.Println("Condition failed")
    }

    // for range 演示
    slice := []int{1, 2, 3}
    for i, v := range slice {
        fmt.Printf("Index: %d, Value: %d\n", i, v)
    }
}

运行结果（预期输出）：

^a    = 11110011 (243)
a &^ b = 00000100 (4)
Condition failed
Index: 0, Value: 1
Index: 1, Value: 2
Index: 2, Value: 3

示例 2：switch 特性与作用域遮蔽

本示例演示 switch 的表达式匹配、if 初始化语句以及变量遮蔽带来的潜在问题。

package main

import "fmt"

func main() {
    // 1. switch 表达式匹配
    score := 85
    switch {
    case score >= 90:
        fmt.Println("A")
    case score >= 80:
        fmt.Println("B")
    default:
        fmt.Println("C")
    }

    // 2. if 初始化语句与作用域
    // val 仅在 if 块内可见
    if val := 10; val > 5 {
        fmt.Println("val inside if:", val)
    }
    // fmt.Println(val) // 错误：val 未定义

    // 3. 变量遮蔽示例
    err := outerError()
    fmt.Println("Outer err:", err)

    // 内部声明了同名的 err，遮蔽了外部的 err
    if innerErr := innerError(); innerErr != nil {
        fmt.Println("Inner err:", innerErr)
        // 这里的 err 是 innerErr，不是外部的 err
    }
    // 外部的 err 仍然是 "outer error"
    fmt.Println("Outer err after if:", err)
}

func outerError() error {
    return fmt.Errorf("outer error")
}

func innerError() error {
    return fmt.Errorf("inner error")
}

运行结果（预期输出）：

B
val inside if: 10
Outer err: outer error
Inner err: inner error
Outer err after if: outer error

四、常见错误与避坑指南

五、最佳实践

六、练习题

1. 概念题：解释 Go 中 fallthrough 的作用及其潜在风险。
2. 编码题：编写一个函数 classifyNumber(n int) string，使用 switch 语句判断 n 是 "positive"、"negative" 还是 "zero"。
3. 进阶/调试题：以下代码旨在打印 0 到 4，但往往输出为空或行为异常。请指出问题并修复。 ```go package main

import ( "fmt" "sync" )

func main() { var wg sync.WaitGroup for i := 0; i < 5; i++ { wg.Add(1) go func() { fmt.Println(i) wg.Done() }() } } ```

七、练习参考答案

package main

import "fmt"

func classifyNumber(n int) string {
    switch {
    case n > 0:
        return "positive"
    case n < 0:
        return "negative"
    default:
        return "zero"
    }
}

func main() {
    fmt.Println(classifyNumber(10)) // positive
    fmt.Println(classifyNumber(-5)) // negative
    fmt.Println(classifyNumber(0))  // zero
}

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 5; i++ {
        wg.Add(1)
        // 创建局部副本，避免 Go 1.21 及之前的变量捕获问题
        val := i
        go func() {
            fmt.Println(val)
            wg.Done()
        }()
    }
    // 等待所有 goroutine 完成
    wg.Wait()
}

八、本课小结