“纵有疾风来，人生不言弃”，这句话送给正在学习Golang的朋友们，也希望在阅读本文《设计支持多种返回类型的接口方法》后，能够真的帮助到大家。我也会在后续的文章中，陆续更新Golang相关的技术文章，有好的建议欢迎大家在评论留言，非常感谢！

这是此问题的后续内容：具有多个返回类型的接口方法

我有两个略有不同的结构。一个是关于交易结构，另一个是关于传输结构。目标是计算最后的数量。此外，交易结构应实现一些与传输结构不常见的特定功能，反之亦然。最后它们都调用 get() 函数并最终返​​回数量（字符串类型）。我无法做类似的事情 qtygetservice(trade{}).calculatea().get() 其中 qtygetservice() 和 get() 可以从两个结构调用，但 calculatea() 是一种方法仅适用于贸易结构。接口首先看起来有希望解决此类问题，但我面临着该问题具有多个返回类型的接口方法中描述的问题，即接口中的方法必须返回特定类型。返回 interface{} 也不是一个选项，因为我无法像下面的示例中所示链接函数（甚至更不用说 reflect 的使用）。

package main

import (
    "fmt"
)

type Trade struct {
    q   string
    // many other attributes
}

type Transfer struct {
    q   string
    // many other attributes
}

type TradeService struct {
    q       string
    // some other attributes
}

type TransferService struct {
    q       string
    // some other attributes
}

type GetQty struct {
    q       string
    // some other attributes
}

func qtyGetTradeService(str *Trade) *TradeService {
    // some processing on the initial struct
    return &TradeService{
        q: str.q + " TradeService ",
    }
}

func qtyGetTransferService(str *Transfer) *TransferService {
    // some processing on the initial struct
    return &TransferService{
        q: str.q + " TransferService ",
    }
}

func (ts *TradeService) calculateA() *GetQty {
    // some processing on ts
    return &GetQty{
        q: ts.q + " CalculateA ",
    }
}

func (ts *TradeService) calculateB() *GetQty {
    // some processing on ts
    return &GetQty{
        q: ts.q + " CalculateB ",
    }
}

func (ts *TransferService) calculateC() *GetQty {
    // some processing on ts
    return &GetQty{
        q: ts.q + " CalculateC ",
    }
}

func (gq *GetQty) get() string{
    // some processing on gq common to both trade and transfer
    return gq.q + " CommonGet "
}



func main() {
    // this works just fine
    fmt.Println(qtyGetTradeService(&Trade{q: "10"}).calculateA().get())
    fmt.Println(qtyGetTransferService(&Transfer{q: "10"}).calculateC().get())

    // But this would be "better" to do something like this:
    fmt.Println(qtyGetService(&Trade{q: "10"}).calculateA().get())
    fmt.Println(qtyGetService(&Transfer{q: "10"}).calculateC().get())
}

演示链接：https://play.golang.org/p/sbcs_o9sl0k

解决方案

感谢您重新发布问题。在另一个问题的评论中很难提供代码示例。

我在这里看到 2 个选项：

选项 1：

在具有相同签名的所有结构上创建函数 calculate。在您的示例中，没有输入参数，只有返回值。如果情况并非如此，事情会变得有点复杂，选项 2 可能更合适。

注意：链接函数使得在 go 中使用接口变得更加困难。您可能想摆脱它。

示例：

type qty interface{
    calculate() qty // chaining can be problematic. best no return value here.
    get() string // or whatever type get should return
}

func (ts *tradeservice) calculate() qty {
    ts.calculatea()
    return ts
}

func (ts *transferservice) calculate() qty {
    ts.calculatec()
    return ts
}

func main() {
    // now this should 
    fmt.println(qtygetservice(&trade{q: "10"}).calculate().get())
    fmt.println(qtygettransferservice(&transfer{q: "10"}).calculate().get())

    // or without chaining (if the return value is removed from `calculate`):
    printval(qtygetservice(&trade{q: "10"}))
    printval(qtygettransferservice(&transfer{q: "10"}))
}

func printval(service qty) {
    service.calculate()
    fmt.println(service.get())
}

func (ts *someservice) calculate() {}

现在可以用作qty接口。

选项 2：

也可能是情况不那么统一并且更难引入单个界面。

然后您可以使用多个接口并强制转换结构以检查它是否实现了该接口。然后才调用该方法。这或多或少类似于检查结构是否具有某种方法。

type calculatorA interface {
    calculateA()
}

type calculatorB interface {
    calculateB()
}

type getter interface {
    get()
}

func main() {
    service := qtyGetService(&Trade{q: "10"})
    if ok, s := service.(calculatorA); ok {
        s.calculateA()
    }
    if ok, s := service.(calculatorB); ok {
        s.calculateB()
    }
    var val string
    if ok, s := service.(getter); ok {
        val = s.get()
    }
    fmt.Println(val)
}

希望这适用于您的情况并为您提供一些想法。

终于介绍完啦！小伙伴们，这篇关于《设计支持多种返回类型的接口方法》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布Golang相关知识，快来关注吧！