Go语言中实现类型不限通道：接口与interface{}的实践

package main

import (
    "fmt"
    "sync" // 用于等待goroutine完成
)

// Pet 接口定义了所有宠物都应具备的行为
type Pet interface {
    Speak() string
    Name() string
}

// Cat 结构体
type Cat struct {
    name string
}

// Cat 实现 Pet 接口的 Speak 方法
func (c Cat) Speak() string {
    return "Meow!"
}

// Cat 实现 Pet 接口的 Name 方法
func (c Cat) Name() string {
    return c.name
}

// Dog 结构体
type Dog struct {
    name string
}

// Dog 实现 Pet 接口的 Speak 方法
func (d Dog) Speak() string {
    return "Woof!"
}

// Dog 实现 Pet 接口的 Name 方法
func (d Dog) Name() string {
    return d.name
}

func main() {
    // 创建一个传输 Pet 接口类型的通道
    petChannel := make(chan Pet)
    var wg sync.WaitGroup // 用于等待接收goroutine完成

    wg.Add(1) // 增加一个等待计数
    // 启动一个goroutine来接收并处理宠物信息
    go func() {
        defer wg.Done() // goroutine退出时减少等待计数
        for p := range petChannel {
            fmt.Printf("%s says %q\n", p.Name(), p.Speak())
        }
        fmt.Println("宠物通道接收器已关闭。")
    }()

    // 发送不同类型的宠物到通道
    petChannel <- Cat{name: "Whiskers"}
    petChannel <- Dog{name: "Buddy"}
    petChannel <- Cat{name: "Garfield"}

    close(petChannel) // 关闭通道以通知接收goroutine没有更多数据
    wg.Wait()         // 等待接收goroutine完成
}

// 示例片段，非完整可运行代码
ch := make(chan interface{})
ch <- "Hello, Go!" // string
ch <- 123          // int
ch <- true         // bool
ch <- struct{}{}   // 匿名结构体

package main

import (
    "fmt"
    "reflect" // 尽管通常推荐类型切换，但reflect可以获取类型名称
    "sync"
    "time"
)

func main() {
    genericChannel := make(chan interface{})
    var wg sync.WaitGroup

    wg.Add(1)
    go func() {
        defer wg.Done()
        for {
            select {
            case p, ok := <-genericChannel:
                if !ok {
                    fmt.Println("泛型通道接收器已关闭，退出接收goroutine。")
                    return
                }
                // 使用类型切换处理不同类型
                switch value := p.(type) {
                case string:
                    fmt.Printf("收到字符串: %q (长度: %d)\n", value, len(value))
                case int:
                    fmt.Printf("收到整数: %d (类型: %T)\n", value, value)
                case bool:
                    fmt.Printf("收到布尔值: %t\n", value)
                case struct{}:
                    fmt.Printf("收到空结构体: %v\n", value)
                default:
                    // 处理未知类型或兜底逻辑
                    fmt.Printf("收到未知类型。类型: %T, 值: %v\n", value, value)
                    // 如果需要，可以使用 reflect 包获取更详细的类型信息
                    fmt.Printf("Reflect Type Name: %s\n", reflect.TypeOf(value).Name())
                }
            }
        }
    }()

    // 发送多种不同类型的数据
    genericChannel <- "this is a string"
    genericChannel <- 42
    genericChannel <- true
    genericChannel <- struct{}{}
    genericChannel <- 3.14159 // float64
    type MyCustomType struct {
        ID int
    }
    genericChannel <- MyCustomType{ID: 101}

    // 确保goroutine有时间处理所有消息
    time.Sleep(50 * time.Millisecond) // 给予接收goroutine一些处理时间
    close(genericChannel)             // 关闭通道
    wg.Wait()                         // 等待接收goroutine完成
}