如何使用接口联合两个不同的结构？

Question

我有以下代码：

package main

import (
    "log"
)

type Data struct {
    Id int
    Name string
}

type DataError struct {
    Message string
    ErrorCode string
}

func main() {
    response := Data{Id: 100, Name: `Name`}
    if true {
        response = DataError{Message: `message`, ErrorCode: `code`}
    }
    log.Println(response)
}

这段代码returns我出错了：

./start.go:20: cannot use DataError literal (type DataError) as type Data in assignment

似乎我无法分配给 response 不同类型的 var 数据（在我的例子中是 DataError）。我听说可能的解决方案是通过接口联合 Data 和 DataError 结构。或者也许还有其他更好的解决方案？

你能告诉我如何解决这个问题吗？

谢谢

Answer 1

您不能将 "assignable" 以外的 2 个不同类型分配给同一个变量...除非您使用特定的接口签名或空接口。

https://golang.org/ref/spec#Assignability

该代码可以编译：

func main() {
    var response interface{} // empty interface AKA Object AKA void pointer
    response = Data{Id: 100, Name: `Name`}
    if true {
        response = DataError{Message: `message`, ErrorCode: `code`}
    }
    log.Println(response)
}

因为每个类型都实现了空接口，但只有在没有其他选择的情况下你才想这样做。

if 2 types share some methods use a specific interface，例如（伪代码）：

type Responder interface {
    Respond() string
}

type Data struct { /* code */
}

func (d Data) Respond() string { return "" }

type DataError struct { /* code */
}

func (d DataError) Respond() string { return "" }

func main() {

    var response Responder // declared as interface
    response = Data{}
    response = DataError{}
    fmt.Println(response)

}

每当您怀疑快速浏览一下 go 规范是否有用时，它是唯一的权威并且与大多数规范相比写得非常好。大多数情况下，规则 crystal 清晰，这是围棋的优势。

Answer 2

您似乎在尝试创建一个联合类型（ML 语言家族对 "enum" 的称呼）。我知道有几种模式：

0。基本错误处理 (playground)

我怀疑您所做的只是基本的错误处理。在 Go 中，我们使用多个 return 值并检查结果。这几乎肯定是您想要做的：

package main

import (
    "fmt"
    "log"
)

type Data struct {
    ID   int
    Name string
}

type DataError struct {
    Message   string
    ErrorCode string
}

// Implement the `error` interface. `error` is an interface with
// a single `Error() string` method
func (err DataError) Error() string {
    return fmt.Sprintf("%s: %s", err.ErrorCode, err.Message)
}

func SomeFunction(returnData bool) (Data, error) {
    if returnData {
        return Data{ID: 42, Name: "Answer"}, nil
    }
    return Data{}, DataError{
        Message:   "A thing happened",
        ErrorCode: "Oops!",
    }
}

func main() {
    // this bool argument controls whether or not an error is returned
    data, err := SomeFunction(false)
    if err != nil {
        log.Fatalln(err)
    }
    fmt.Println(data)
}

1.接口 (playground)

同样，如果您的选项是好数据和错误，您可能应该使用第一种情况（坚持 idiom/convention），但其他时候您可能有多个 "good data" 选项。我们可以使用接口来解决这个问题。在这里，我们添加了一个虚拟方法来告诉编译器将可以实现此接口的可能类型限制为具有 IsResult() 方法的类型。这样做的最大缺点是将东西粘贴到接口中会导致分配，这在紧密循环中可能是有害的。这种模式不是很常见。

package main

import "fmt"

type Result interface {
    // a dummy method to limit the possible types that can
    // satisfy this interface
    IsResult()
}

type Data struct {
    ID   int
    Name string
}

func (d Data) IsResult() {}

type DataError struct {
    Message   string
    ErrorCode string
}

func (err DataError) IsResult() {}

func SomeFunction(isGoodData bool) Result {
    if isGoodData {
        return Data{ID: 42, Name: "answer"}
    }
    return DataError{Message: "A thing happened", ErrorCode: "Oops!"}
}

func main() {
    fmt.Println(SomeFunction(true))
}

2。标记联盟 (playground)

这种情况与前面的情况类似，除了我们不使用接口，而是使用带有标签的结构，该标签告诉我们该结构包含哪种类型的数据（这类似于 C 中的标记联合，除了结构的大小是其潜在类型的总和而不是其最大潜在类型的大小）。虽然这占用了更多 space，但它可以很容易地进行堆栈分配，从而使其成为紧密循环友好的（我使用这种技术将分配从 O(n) 减少到 O(1)）。在这种情况下，我们的标签是 bool，因为我们只有两种可能的类型（Data 和 DataError），但您也可以使用类似 C 的枚举。

package main

import (
    "fmt"
)

type Data struct {
    ID   int
    Name string
}

type DataError struct {
    Message   string
    ErrorCode string
}

type Result struct {
    IsGoodData bool
    Data       Data
    Error      DataError
}

// Implements the `fmt.Stringer` interface; this is automatically
// detected and invoked by fmt.Println() and friends
func (r Result) String() string {
    if r.IsGoodData {
        return fmt.Sprint(r.Data)
    }
    return fmt.Sprint(r.Error)
}

func SomeFunction(isGoodData bool) Result {
    if isGoodData {
        return Result{
            IsGoodData: true,
            Data:       Data{ID: 42, Name: "Answer"},
        }
    }
    return Result{
        IsGoodData: false,
        Error: DataError{
            Message:   "A thing happened",
            ErrorCode: "Oops!",
        },
    }
}

func main() {
    // this bool argument controls whether or not an error is returned
    fmt.Println(SomeFunction(true))
}

如何使用接口联合两个不同的结构？

How to unite two different struct using interface?

struct

interface

go

go-interface