Go语言Type Switch：深入理解t变量的类型行为

switch i.(type) {
case Type1:
    // 当i持有Type1类型的值时执行
case Type2:
    // 当i持有Type2类型的值时执行
default:
    // 当i持有其他类型的值时执行
}

package main

import "fmt"

// 定义一个接口
type MyInterface interface {
    MyMethod() string
}

// 定义实现MyInterface的结构体A
type MyStructA struct {
    Name string
}

func (m MyStructA) MyMethod() string {
    return "MyStructA: " + m.Name
}

// 定义实现MyInterface的结构体B
type MyStructB struct {
    Value int
}

func (m MyStructB) MyMethod() string {
    return fmt.Sprintf("MyStructB: %d", m.Value)
}

// 定义一个未实现MyInterface的普通结构体
type MyStructC struct {
    ID string
}

func main() {
    var im MyInterface // 声明一个接口变量

    // 场景1: im  holding MyStructA
    im = MyStructA{Name: "Alice"}
    fmt.Println("--- 场景1: MyStructA ---")
    processInterface(im)

    // 场景2: im holding MyStructB
    im = MyStructB{Value: 123}
    fmt.Println("--- 场景2: MyStructB ---")
    processInterface(im)

    // 场景3: im holding a pointer to MyStructA
    im = &MyStructA{Name: "Bob"} // 接口也可以持有指针
    fmt.Println("--- 场景3: *MyStructA ---")
    processInterface(im)

    // 场景4: im holding nil
    im = nil
    fmt.Println("--- 场景4: nil ---")
    processInterface(im)

    // 场景5: im holding a type that does not implement MyInterface (will cause panic if assigned directly,
    // but for illustration, imagine it came from an 'interface{}' which then was asserted to MyInterface)
    // For a more realistic default case, let's use a non-interface type.
    // Here, we can't assign MyStructC to MyInterface directly,
    // but if we had `var any interface{} = MyStructC{ID: "C1"}` and then `im = any.(MyInterface)`
    // it would panic. A default case is typically for types that *do* implement the interface
    // but aren't explicitly handled, or for `nil`.
    // Let's modify processInterface to take interface{} for a more general default.
}

func processInterface(im MyInterface) {
    switch t := im.(type) {
    case MyStructA:
        // 在此case中，t的类型是MyStructA
        fmt.Printf("Case MyStructA: t的类型是 %T, t.Name = %s\n", t, t.Name)
        fmt.Printf("t.MyMethod() = %s\n", t.MyMethod())
    case *MyStructA:
        // 在此case中，t的类型是*MyStructA
        fmt.Printf("Case *MyStructA: t的类型是 %T, t.Name = %s\n", t, t.Name)
        fmt.Printf("t.MyMethod() = %s\n", t.MyMethod())
    case MyStructB:
        // 在此case中，t的类型是MyStructB
        fmt.Printf("Case MyStructB: t的类型是 %T, t.Value = %d\n", t, t.Value)
        fmt.Printf("t.MyMethod() = %s\n", t.MyMethod())
    case nil:
        // 当接口变量为nil时
        fmt.Println("Case nil: 接口变量为nil")
    default:
        // 在此default中，t的类型仍然是MyInterface
        fmt.Printf("Default case: t的类型是 %T, t.MyMethod() = %s\n", t, t.MyMethod())
        // 如果想访问原始类型，需要再次断言
        // if originalType, ok := t.(MyStructC); ok {
        //     fmt.Printf("Original type was MyStructC: %s\n", originalType.ID)
        // }
    }
}

--- 场景1: MyStructA ---
Case MyStructA: t的类型是 main.MyStructA, t.Name = Alice
t.MyMethod() = MyStructA: Alice
--- 场景2: MyStructB ---
Case MyStructB: t的类型是 main.MyStructB, t.Value = 123
t.MyMethod() = MyStructB: 123
--- 场景3: *MyStructA ---
Case *MyStructA: t的类型是 *main.MyStructA, t.Name = Bob
t.MyMethod() = MyStructA: Bob
--- 场景4: nil ---
Case nil: 接口变量为nil