Go语言中接口集合类型参数传递的深入理解与实践

package main

import "fmt"

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

// 定义一个实现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: %s\n", k, v.bar())
    }
}

func main() {
    // 尝试创建一个map[string]baz并传递给doSomething
    itemsConcrete := map[string]baz{"a": baz{}}
    // doSomething(itemsConcrete) // 这会导致编译错误！
    // 错误信息: cannot use itemsConcrete (type map[string]baz) as type map[string]foo in argument to doSomething

    fmt.Println("Attempting to pass map[string]baz directly results in a compile error.")
}

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: %s\n", k, v.bar())
    }
}

func main() {
    // 直接声明一个map[string]foo类型的map
    itemsInterface := map[string]foo{"a": baz{}} 

    // 现在可以成功传递
    doSomething(itemsInterface) 
    // 输出: Key: a, Value: hello from baz
}

package main

import "fmt"

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

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

// 定义一个实现两个接口的具体类型
type myType struct{}

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

func (m myType) baz() string {
    return "hello from myType (foobar)"
}

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

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

func main() {
    // 创建一个map[string]interface{}来存储不同类型的值
    // 这里的myType实现了foo和foobar接口
    genericItems := map[string]interface{}{
        "item1": myType{},
        "item2": myType{},
    }

    // 1. 传递给需要map[string]foo的函数
    // 需要创建一个新的map[string]foo，并将genericItems中的值进行类型断言
    fooItems := make(map[string]foo)
    for k, v := range genericItems {
        if f, ok := v.(foo); ok { // 类型断言：v是否实现了foo接口
            fooItems[k] = f
        } else {
            fmt.Printf("Warning: Item %s does not implement foo interface.\n", k)
        }
    }
    processFoo(fooItems)

    // 2. 传递给需要map[string]foobar的函数
    // 同样，创建一个新的map[string]foobar，并进行类型断言
    foobarItems := make(map[string]foobar)
    for k, v := range genericItems {
        if fb, ok := v.(foobar); ok { // 类型断言：v是否实现了foobar接口
            foobarItems[k] = fb
        } else {
            fmt.Printf("Warning: Item %s does not implement foobar interface.\n", k)
        }
    }
    processFoobar(foobarItems)

    // 也可以在函数内部进行类型断言，但通常更推荐在外部准备好所需类型
    fmt.Println("\nDemonstrating in-place type assertion within a loop:")
    for k, v := range genericItems {
        if f, ok := v.(foo); ok {
            fmt.Printf("Item %s as foo: %s\n", k, f.bar())
        }
        if fb, ok := v.(foobar); ok {
            fmt.Printf("Item %s as foobar: %s\n", k, fb.baz())
        }
    }
}