Go 1.18 中如何实现一个方法返回两个不同的具体类型？

你在学习Golang相关的知识吗？本文《Go 1.18 中如何实现一个方法返回两个不同的具体类型？》，主要介绍的内容就涉及到，如果你想提升自己的开发能力，就不要错过这篇文章，大家要知道编程理论基础和实战操作都是不可或缺的哦！

假设我有这段代码：

type type1 struct {
    name string `json:"name,omitempty"`
    path string `json:"path"`
    file string `json:"file"`
    tag  int    `json:"tag"`
    num  int    `json:"num"`
}

func loadconfiguration(data []byte) (*type1, error) {
    config, err := loadconf1(data)
    if err != nil {
        return nil, err
    }
    confother, err := loadconfother1()
    if err != nil {
        return nil, err
    }
    // do something with confother
    fmt.println("confother", confother)
    if confother.tag == 0 {
        config.num = 5
    }

    // do something with config attributes of type1
    if config.tag == 0 {
        config.tag = 5
    }
    if config.num == 0 {
        config.num = 4
    }

    return config, nil
}

func loadconf1(bytes []byte) (*type1, error) {
    config := &type1{}
    if err := json.unmarshal(bytes, config); err != nil {
        return nil, fmt.errorf("cannot load config: %v", err)
    }

    return config, nil
}

func loadconfother1() (*type1, error) {
    // return value of this specific type
    flatconfig := &type1{}

    // read a file as []byte
    // written as a fixed array to simplify this example
    filecontent := []byte{10, 22, 33, 44, 55}

    if err := json.unmarshal(filecontent, flatconfig); err != nil {
        return nil, fmt.errorf("cannot read config %v", err)
    }

    return flatconfig, nil
}

唯一的公共函数是 loadconfiguration。

它基于真实的代码，用于将 json 数据读取为特定的结构。如果有些东西看起来没用，那是因为我简化了原始代码。

上面的代码没问题，但现在我想创建另一个名为“type2”的结构类型，并重新使用相同的方法将数据读入 type2，而无需复制和粘贴所有内容。

type Type2 struct {
    Name  string                  `json:"name,omitempty"`
    Path  string                  `json:"path"`
    Map   *map[string]interface{} `json:"map"`
    Other string                  `json:"other"`
}

基本上，我希望能够调用 loadconfiguration 来获取 type2。我可以接受调用 loadconfiguration2 等特定方法，但我不想也复制和粘贴 loadconf1 和 loadconfother1。 在 go 1.18 中有没有一种方法可以以惯用的方式做到这一点？

正确答案

实际上，您的问题中显示的代码除了将类型传递到 json.unmarshal 并格式化错误之外，没有做任何其他事情，以便您可以重写函数以使其表现得像它一样：

func loadconfiguration(data []byte) (*type1, error) {
    config := &type1{}
    if err := loadconf(data, config); err != nil {
        return nil, err
    }
    // ...
}

// "magically" accepts any type
// you could actually get rid of the intermediate function altogether
func loadconf(bytes []byte, config any) error {
    if err := json.unmarshal(bytes, config); err != nil {
        return fmt.errorf("cannot load config: %v", err)
    }
    return nil
}

如果代码实际上执行的操作不仅仅是将指针传递给 json.unmarshal，那么它可以从类型参数中受益。

type configurations interface {
    type1 | type2
}

func loadconf[t configurations](bytes []byte) (*t, error) {
    config := new(t)
    if err := json.unmarshal(bytes, config); err != nil {
        return nil, fmt.errorf("cannot load config: %v", err)
    }
    return config, nil
}

func loadconfother[t configurations]() (*t, error) {
    flatconfig := new(t)
    // ... code
    return flatconfig, nil
}

在这些情况下，您可以使用 new(t) 创建任一类型的新指针，然后使用 json。unmarshal 将负责将字节切片或文件的内容反序列化到其中 — 前提是 json 实际上可以解组为任一结构。

顶级函数中的特定于类型的代码仍然应该不同，特别是因为您想要使用显式具体类型实例化泛型函数。所以我建议保留 loadconfiguration1 和 loadconfiguration2。

func loadconfiguration1(data []byte) (*type1, error) {
    config, err := loadconf[type1](data)
    if err != nil {
        return nil, err
    }
    confother, err := loadconfother[type1]()
    if err != nil {
        return nil, err
    }

    // ... type specific code

    return config, nil
}

但是，如果特定于类型的代码只是其中的一小部分，您可能可以对特定部分进行类型切换，尽管在您的情况下这似乎不是一个可行的选择。我会看起来像：

func LoadConfiguration[T Configuration](data []byte) (*T, error) {
    config, err := loadConf[T](data)
    if err != nil {
        return nil, err
    }
    // let's pretend there's only one value of type parameter type
    // type-specific code
    switch t := config.(type) {
        case *Type1:
            // ... some *Type1 specific code
        case *Type2:
            // ... some *Type2 specific code
        default:
            // can't really happen because T is restricted to Configuration but helps catch errors if you extend the union and forget to add a corresponding case
            panic("invalid type")
    }

    return config, nil
}

最小示例演示：https://go.dev/play/p/-rhIgoxINTZ

今天关于《Go 1.18 中如何实现一个方法返回两个不同的具体类型？》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！