Go语言中接口集合类型参数的传递与类型转换解析

package main

import "fmt"

// 定义一个接口 foo，包含 bar() 方法
type foo interface {
    bar() string
}

// 定义一个具体类型 baz，实现 foo 接口
type baz struct{}

func (b baz) bar() string {
    return "hello from baz"
}

// 定义一个函数，接受 map[string]foo 类型的参数
func doSomething(items map[string]foo) {
    for k, v := range items {
        fmt.Printf("doSomething: Key: %s, Value.bar(): %s\n", k, v.bar())
    }
}

func main() {
    // 正确的做法：直接创建 map[string]foo，并将 baz 实例作为 foo 接口值存储
    items := map[string]foo{
        "a": baz{}, // baz{} 被隐式转换为 foo 接口值
    }

    doSomething(items) // 此时可以成功调用
}

package main

import "fmt"

// 定义第一个接口 foo
type foo interface {
    bar() string
}

// 定义第二个接口 foobar
type foobar interface {
    baz() int
}

// 定义一个具体类型 myStruct，实现 foo 和 foobar 接口
type myStruct struct{}

func (m myStruct) bar() string {
    return "hello from myStruct (foo)"
}

func (m myStruct) baz() int {
    return 42 // some integer
}

// 接受 map[string]foo 的函数
func processFoo(items map[string]foo) {
    fmt.Println("\n--- Processing with foo interface ---")
    for k, v := range items {
        fmt.Printf("Key: %s, Value.bar(): %s\n", k, v.bar())
    }
}

// 接受 map[string]foobar 的函数
func processFoobar(items map[string]foobar) {
    fmt.Println("\n--- Processing with foobar interface ---")
    for k, v := range items {
        fmt.Printf("Key: %s, Value.baz(): %d\n", k, v.baz())
    }
}

func main() {
    // 存储通用接口类型 interface{} 的map
    generalItems := make(map[string]interface{})
    generalItems["item1"] = myStruct{} // myStruct 实例被存储为 interface{}

    // 准备传递给 processFoo 函数
    fooMap := make(map[string]foo)
    for k, v := range generalItems {
        // 进行类型断言，检查值是否实现了 foo 接口
        if f, ok := v.(foo); ok {
            fooMap[k] = f // 将断言成功的接口值添加到新的 map[string]foo 中
        } else {
            fmt.Printf("Warning: Item %s does not implement foo interface.\n", k)
        }
    }
    processFoo(fooMap)

    // 准备传递给 processFoobar 函数
    foobarMap := make(map[string]foobar)
    for k, v := range generalItems {
        // 进行类型断言，检查值是否实现了 foobar 接口
        if fb, ok := v.(foobar); ok {
            foobarMap[k] = fb // 将断言成功的接口值添加到新的 map[string]foobar 中
        } else {
            fmt.Printf("Warning: Item %s does not implement foobar interface.\n", k)
        }
    }
    processFoobar(foobarMap)
}