Go语言中接口集合类型作为函数参数的深度解析

package main

import "fmt"

// 定义一个接口 foo
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("Key: %s, Value (bar method): %s\n", k, v.bar())
    }
}

func main() {
    // 尝试创建一个 map[string]baz 类型
    itemsBaz := map[string]baz{"a": baz{}}

    // 编译错误：cannot use itemsBaz (type map[string]baz) as type map[string]foo in argument to doSomething
    // doSomething(itemsBaz)

    fmt.Println("尝试直接传递 map[string]baz 会导致编译错误。")
}

package main

import "fmt"

type foo interface {
    bar() string
}

type baz struct{}

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

func doSomething(items map[string]foo) {
    for k, v := range items {
        fmt.Printf("Key: %s, Value (bar method): %s\n", k, v.bar())
    }
}

func main() {
    // 声明 map 时直接指定其值为 foo 接口类型
    itemsFoo := map[string]foo{"a": baz{}} // 注意这里的值类型是 foo

    // 现在可以成功调用 doSomething 函数
    doSomething(itemsFoo)
    // Output: Key: a, Value (bar method): hello from baz
}

package main

import "fmt"

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

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

// 定义一个结构体，同时实现 foo 和 foobar 接口
type myStruct struct{}

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

func (m myStruct) baz() int {
    return 42
}

// 接收 map[string]interface{}，并处理为 foo 接口
func processAsFoo(items map[string]interface{}) {
    fmt.Println("\n--- Processing as foo interface ---")
    for k, v := range items {
        if f, ok := v.(foo); ok { // 类型断言，检查是否实现了 foo 接口
            fmt.Printf("Key: %s, implements foo.bar(): %s\n", k, f.bar())
        } else {
            fmt.Printf("Key: %s, does NOT implement foo\n", k)
        }
    }
}

// 接收 map[string]interface{}，并处理为 foobar 接口
func processAsFoobar(items map[string]interface{}) {
    fmt.Println("\n--- Processing as foobar interface ---")
    for k, v := range items {
        if fb, ok := v.(foobar); ok { // 类型断言，检查是否实现了 foobar 接口
            fmt.Printf("Key: %s, implements foobar.baz(): %d\n", k, fb.baz())
        } else {
            fmt.Printf("Key: %s, does NOT implement foobar\n", k)
        }
    }
}

func main() {
    // 创建一个 map[string]interface{}，可以存储任何类型
    flexibleMap := map[string]interface{}{
        "item1": myStruct{},       // myStruct 实现了 foo 和 foobar
        "item2": "just a string",  // 字符串未实现任何接口
        "item3": baz{},            // baz 实现了 foo
    }

    // 将同一个 map 传递给不同的处理函数
    processAsFoo(flexibleMap)
    processAsFoobar(flexibleMap)
}

--- Processing as foo interface ---
Key: item1, implements foo.bar(): hello from myStruct (foo)
Key: item2, does NOT implement foo
Key: item3, implements foo.bar(): hello from baz

--- Processing as foobar interface ---
Key: item1, implements foobar.baz(): 42
Key: item2, does NOT implement foobar
Key: item3, does NOT implement foobar