实现 Go 语言中的类型无关通道：泛型数据传输实践

package main

import "fmt"

// 定义一个 Pet 接口，所有宠物都应该能 Speak
type Pet interface {
    Speak() string
    Name() string
}

// Dog 类型实现 Pet 接口
type Dog struct {
    dogName string
}

func (d Dog) Speak() string {
    return "Woof! Woof!"
}
func (d Dog) Name() string {
    return d.dogName
}

// Cat 类型实现 Pet 接口
type Cat struct {
    catName string
}

func (c Cat) Speak() string {
    return "Meow~"
}
func (c Cat) Name() string {
    return c.catName
}

func main() {
    // 创建一个 Pet 接口类型的通道
    petChannel := make(chan Pet)

    go func() {
        // 向通道发送 Dog 和 Cat 实例
        petChannel <- Dog{dogName: "Buddy"}
        petChannel <- Cat{catName: "Whiskers"}
        close(petChannel) // 发送完毕，关闭通道
    }()

    // 接收并处理通道中的宠物
    for p := range petChannel {
        fmt.Printf("%s says: %s\n", p.Name(), p.Speak())
    }
}

package main

import "fmt"

func main() {
    genericChannel := make(chan interface{})

    go func() {
        genericChannel <- "Hello, Go!"      // string
        genericChannel <- 123               // int
        genericChannel <- true              // bool
        genericChannel <- 3.14              // float64
        genericChannel <- struct{ Name string }{"Gopher"} // 匿名结构体
        close(genericChannel)
    }()

    // 接收端需要处理这些不同类型的数据
    // ... (见下文两种处理策略)
}

package main

import "fmt"

func main() {
    genericChannel := make(chan interface{})

    go func() {
        genericChannel <- "Hello, Go!"
        genericChannel <- 123
        genericChannel <- true
        genericChannel <- 3.14
        genericChannel <- struct{ Name string }{"Gopher"}
        close(genericChannel)
    }()

    for p := range genericChannel {
        // 使用类型断言的 switch 语句来判断接收到的类型
        switch v := p.(type) {
        case string:
            fmt.Printf("接收到字符串: %q\n", v)
        case int:
            fmt.Printf("接收到整数: %d\n", v)
        case bool:
            fmt.Printf("接收到布尔值: %t\n", v)
        case float64:
            fmt.Printf("接收到浮点数: %f\n", v)
        default:
            // 处理所有未明确列出的类型
            fmt.Printf("接收到未知类型: %T, 值为: %v\n", v, v)
        }
    }
}

package main

import (
    "fmt"
    "reflect" // 引入 reflect 包
)

func main() {
    genericChannel := make(chan interface{})

    go func() {
        genericChannel <- "this is it"
        genericChannel <- 42
        genericChannel <- struct{ ID int }{ID: 101}
        close(genericChannel)
    }()

    for p := range genericChannel {
        // 使用 reflect.TypeOf() 获取类型信息
        fmt.Printf("接收到类型: %q, 值为: %v\n", reflect.TypeOf(p).Name(), p)
        // 如果需要获取值，可以使用 reflect.ValueOf()
        // v := reflect.ValueOf(p)
        // fmt.Printf("反射获取的值: %v\n", v)
    }
}