Golang中如何传递从不同包返回的结构体到main.go定义的函数中

Golang中如何传递从不同包返回的结构体到main.go定义的函数中 新手警报！

我正在尝试从辅助包中获取结构体（到 main.go），然后将其传递给 main.go 中定义的一个简单函数。

辅助包：

路径：modules/helper.go

package modules

type Test struct {
    Name string
}

func GetString() Test {
    t := Test{Name: "bar"}
    return t
}

main.go：

package main

import (
    "fmt"
    "learnGo/modules"
)

type Info struct {
    Name string
}

func printName(s Info) Info {
    return s

}

func main() {
    i := Info{Name: "foo"}

    resp := printName(i)
    fmt.Println(resp)

    // 从模块获取

    j := modules.GetString()
    resp1 := printName(j)
    fmt.Println(resp1)

}

错误：

./main.go:26:20: cannot use j (type modules.Test) as type Info in argument to printName

我理解失败的原因是函数 printName 期望 Info 结构体，而返回类型是 modules.Test。

处理这种情况的最佳方法是什么？在函数参数中使用接口吗？

提前感谢。


更多关于Golang中如何传递从不同包返回的结构体到main.go定义的函数中的实战教程也可以访问 https://www.itying.com/category-94-b0.html

2 回复

prahlad_kumar:

处理这种情况的最佳方法是什么？在函数参数中使用接口吗？

这可能是一个解决方案。让 Test 和 Info 都实现一个能被 printName 接受的接口。

更多关于Golang中如何传递从不同包返回的结构体到main.go定义的函数中的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


在Go语言中，处理不同包的结构体类型不匹配问题，有几种常见方案。以下是具体实现示例：

方案1：使用接口（推荐）

// modules/helper.go
package modules

type Test struct {
    Name string
}

func (t Test) GetName() string {
    return t.Name
}

func GetString() Test {
    return Test{Name: "bar"}
}

// main.go
package main

import (
    "fmt"
    "learnGo/modules"
)

type Namer interface {
    GetName() string
}

func printName(n Namer) {
    fmt.Println(n.GetName())
}

func main() {
    j := modules.GetString()
    printName(j) // 输出: bar
}

方案2：类型转换（如果结构体字段相同）

// modules/helper.go
package modules

type Test struct {
    Name string
}

func GetString() Test {
    return Test{Name: "bar"}
}

// main.go
package main

import (
    "fmt"
    "learnGo/modules"
)

type Info struct {
    Name string
}

func printName(s Info) {
    fmt.Println(s.Name)
}

func main() {
    j := modules.GetString()
    
    // 显式转换
    info := Info{Name: j.Name}
    printName(info) // 输出: bar
}

方案3：通用处理函数

// modules/helper.go
package modules

type Test struct {
    Name string
}

func GetString() Test {
    return Test{Name: "bar"}
}

// main.go
package main

import (
    "fmt"
    "learnGo/modules"
)

type Info struct {
    Name string
}

func printAnyName(name string) {
    fmt.Println(name)
}

func main() {
    j := modules.GetString()
    printAnyName(j.Name) // 输出: bar
}

方案4：嵌入结构体

// modules/helper.go
package modules

type Test struct {
    Name string
}

func GetString() Test {
    return Test{Name: "bar"}
}

// main.go
package main

import (
    "fmt"
    "learnGo/modules"
)

type Info struct {
    modules.Test
}

func printName(s Info) {
    fmt.Println(s.Name)
}

func main() {
    j := modules.GetString()
    info := Info{Test: j}
    printName(info) // 输出: bar
}

方案5：使用泛型（Go 1.18+）

// modules/helper.go
package modules

type Test struct {
    Name string
}

func GetString() Test {
    return Test{Name: "bar"}
}

// main.go
package main

import (
    "fmt"
    "learnGo/modules"
)

type Info struct {
    Name string
}

func printName[T any](item T, getName func(T) string) {
    fmt.Println(getName(item))
}

func main() {
    j := modules.GetString()
    printName(j, func(t modules.Test) string {
        return t.Name
    }) // 输出: bar
    
    i := Info{Name: "foo"}
    printName(i, func(info Info) string {
        return info.Name
    }) // 输出: foo
}

最常用的方案是接口方案，它提供了良好的解耦和扩展性。选择哪种方案取决于具体的使用场景和需求。

回到顶部