Go语言中空白标识符_的妙用解析

package main

import (
    "bufio"
    "bytes"
    "fmt"
)

func main() {
    reader := bufio.NewReader(bytes.NewBufferString("Hello, Go!"))

    // ReadRune() 返回 rune, size, error。我们只关心 rune 和 error。
    r, _, err := reader.ReadRune()
    if err != nil {
        fmt.Printf("读取字符时发生错误: %v\n", err)
        return
    }
    fmt.Printf("读取到的字符: %c\n", r) // 输出: 读取到的字符: H
}

package main

import (
    "fmt" // 导入了 fmt 包
    // "log" // 如果 log 包被导入但未使用，会报错
)

func main() {
    // 假设我们暂时不需要使用 fmt.Println，但又不想删除 import "fmt"
    var _ = fmt.Println // 将 fmt.Println 赋值给空白标识符，表示 fmt 包已被使用

    var x int // 声明了一个局部变量 x
    // 假设我们暂时不需要使用 x
    _ = x // 将 x 赋值给空白标识符，表示 x 已被使用

    // fmt.Println("Hello, world!") // 正常使用 fmt 包
}

package main

import "fmt"

// 定义一个接口
type Speaker interface {
    Speak() string
}

// 定义一个结构体
type Dog struct{}

// Dog 结构体实现了 Speak() 方法
func (d Dog) Speak() string {
    return "Woof!"
}

// 定义另一个结构体，没有实现 Speak() 方法
type Cat struct{}

func main() {
    // 编译时检查 Dog 类型是否实现了 Speaker 接口
    var _ Speaker = Dog{} // 如果 Dog 没有实现 Speaker，这里会产生编译错误
    // var _ Speaker = Cat{} // 这行代码会报错：Cat does not implement Speaker (missing Speak method)

    var s Speaker = Dog{}
    fmt.Println(s.Speak()) // 输出: Woof!
}

package main

const (
    MaxLimit = 10
    MinLimit = 1
)

func main() {
    const constVal1 = 5
    const constVal2 = 15 // 超过 MaxLimit
    const constVal3 = 0  // 低于 MinLimit

    // 确保 constVal1 <= MaxLimit
    // 如果 constVal1 > MaxLimit，则 (MaxLimit - constVal1) 为负数，
    // 赋值给无符号整型会溢出，导致编译错误。
    const _ uint = MaxLimit - constVal1 // 编译通过

    // 确保 constVal2 <= MaxLimit
    // const _ uint = MaxLimit - constVal2 // 编译错误：constant -5 overflows uint

    // 确保 constVal1 >= MinLimit
    // 如果 constVal1 < MinLimit，则 (-1 + constVal1) 为负数，
    // 赋值给无符号整型会溢出，导致编译错误。
    const _ uint = -1 + constVal1 // 编译通过 (等价于 constVal1 - 1)

    // 确保 constVal3 >= MinLimit
    // const _ uint = -1 + constVal3 // 编译错误：constant -1 overflows uint
}

package main

import "fmt"

// 定义一个函数类型，接受两个 int 参数并返回一个 int
type BinaryOperation func(int, int) int

// identity 函数实现了 BinaryOperation 签名，但只使用了第一个参数
func identity(x, _ int) int {
    return x
}

func main() {
    var op BinaryOperation
    op = identity

    result := op(10, 20) // 第二个参数 20 被 identity 函数忽略
    fmt.Printf("操作结果: %d\n", result) // 输出: 操作结果: 10
}