Go语言中map、range和类型断言的特殊多值返回机制解析

package main

import "fmt"

func f2() (k, v string) {
    return "Hello", "World"
}

func main() {
    // 错误示例：试图将多个返回值赋给单个变量
    // k := f2() // 编译错误：multiple-value f2() in single-value context

    // 正确处理方式一：接收所有返回值
    k, v := f2()
    fmt.Printf("k: %s, v: %s\n", k, v) // 输出: k: Hello, v: World

    // 正确处理方式二：使用下划线忽略不需要的返回值
    val, _ := f2()
    fmt.Printf("val: %s\n", val) // 输出: val: Hello

    // 正确处理方式三：完全忽略所有返回值 (如果函数有副作用，可能有用)
    f2()
}

package main

import "fmt"

func main() {
    m := map[string]int{"One": 1, "Zero": 0}

    // 单值接收：无法判断键是否存在
    v1 := m["One"]
    fmt.Printf("m[\"One\"] (单值): %d\n", v1) // 输出: m["One"] (单值): 1

    v2 := m["Two"]
    fmt.Printf("m[\"Two\"] (单值): %d\n", v2) // 输出: m["Two"] (单值): 0 (键不存在，返回零值)

    v3 := m["Zero"]
    fmt.Printf("m[\"Zero\"] (单值): %d\n", v3) // 输出: m["Zero"] (单值): 0 (键存在，返回零值)

    // 双值接收：可判断键是否存在
    val, ok := m["One"]
    if ok {
        fmt.Printf("m[\"One\"] (双值): %d, 键存在\n", val) // 输出: m["One"] (双值): 1, 键存在
    }

    val, ok = m["Two"]
    if !ok {
        fmt.Printf("m[\"Two\"] (双值): %d, 键不存在\n", val) // 输出: m["Two\"] (双值): 0, 键不存在
    }
}

package main

import "fmt"

func main() {
    m := map[string]int{"Apple": 1, "Banana": 2, "Cherry": 3}
    s := []string{"Red", "Green", "Blue"}

    fmt.Println("--- map 的 range 循环 ---")
    // map 的单值接收：只获取键
    for key := range m {
        fmt.Printf("键: %s\n", key)
    }
    // 输出: 键: Apple, 键: Banana, 键: Cherry (顺序不确定)

    // map 的双值接收：获取键和值
    for key, value := range m {
        fmt.Printf("键: %s, 值: %d\n", key, value)
    }
    // 输出: 键: Apple, 值: 1, 键: Banana, 值: 2, 键: Cherry, 值: 3 (顺序不确定)

    fmt.Println("\n--- 切片的 range 循环 ---")
    // 切片的单值接收：只获取索引
    for index := range s {
        fmt.Printf("索引: %d\n", index)
    }
    // 输出: 索引: 0, 索引: 1, 索引: 2

    // 切片的双值接收：获取索引和值
    for index, value := range s {
        fmt.Printf("索引: %d, 值: %s\n", index, value)
    }
    // 输出: 索引: 0, 值: Red, 索引: 1, 值: Green, 索引: 2, 值: Blue
}

package main

import "fmt"

func main() {
    var i interface{} = "Hello Go"
    var j interface{} = 123
    var k interface{} = nil

    // 双值接收：安全断言
    s, ok := i.(string)
    if ok {
        fmt.Printf("i 断言为 string 成功: %s\n", s) // 输出: i 断言为 string 成功: Hello Go
    } else {
        fmt.Println("i 断言为 string 失败")
    }

    n, ok := j.(int)
    if ok {
        fmt.Printf("j 断言为 int 成功: %d\n", n) // 输出: j 断言为 int 成功: 123
    } else {
        fmt.Println("j 断言为 int 失败")
    }

    b, ok := i.(bool)
    if ok {
        fmt.Printf("i 断言为 bool 成功: %t\n", b)
    } else {
        fmt.Println("i 断言为 bool 失败") // 输出: i 断言为 bool 失败
    }

    // 单值接收：可能触发 panic
    // val := k.(string) // 如果 k 为 nil，会 panic
    // fmt.Println(val)

    // val := j.(string) // 如果 j 不是 string 类型，会 panic
    // fmt.Println(val)
}