将数据从结构 X 复制到结构 Y，但将一个字段转换为不同类型

golang学习网今天将给大家带来《将数据从结构 X 复制到结构 Y，但将一个字段转换为不同类型》，感兴趣的朋友请继续看下去吧！以下内容将会涉及到等等知识点，如果你是正在学习Golang或者已经是大佬级别了，都非常欢迎也希望大家都能给我建议评论哈~希望能帮助到大家！

我是静态类型语言的新手，我正在尝试自学 golang，并且正在制作一个小型的 rest api 项目来学习。

我正在像这样调用 grpc 服务

func (m *marketsservice) getallmarkets(ctx context.context) (*markets.alldata, error) {
    ctx, cancel := context.withtimeout(ctx, time.hour)
    defer cancel()

    r, err := m.client.getalldata(ctx, &markets.noparams{})

    if err != nil {
        return nil, err
    }

    return r, nil
}

我通过 gin 服务器将响应发送到前端，就像这样，它工作正常。前端接收数据。

func getallmarketshandler(c *gin.context) {
        now := time.now().unixnano()
        code := http.statusok

        allmarkets, err := grpcmarketsservice.getallmarkets(context.background())

        if err != nil {
            err := err.(*errorhttp)
            sendresponse(c, "", now, err.code, err.message)
            return
        }

        sendresponse(c, "", now, code, &response)
    }

但是 grpc 响应中的一些参数是枚举。我想在用 gin 发送响应之前将枚举转换为字符串。下面是我从 grpc 调用收到的原始消息

type alldata struct {
    state         protoimpl.messagestate
    sizecache     protoimpl.sizecache
    unknownfields protoimpl.unknownfields

    marketinfos        []*marketinfo        `protobuf:"bytes,1,rep,name=marketinfos,proto3" json:"marketinfos"`
    leverageprofiles   []*leverageprofile   `protobuf:"bytes,2,rep,name=leverageprofiles,proto3" json:"leverageprofiles"`
    protectionprofiles []*protectionprofile `protobuf:"bytes,3,rep,name=protectionprofiles,proto3" json:"protectionprofiles"`
    volumeprofiles     []*volumeprofile     `protobuf:"bytes,4,rep,name=volumeprofiles,proto3" json:"volumeprofiles"`
}

type marketinfo struct {
    state         protoimpl.messagestate
    sizecache     protoimpl.sizecache
    unknownfields protoimpl.unknownfields

    marketid                 string             `protobuf:"bytes,1,opt,name=marketid,proto3" json:"marketid"`
    name                     string             `protobuf:"bytes,2,opt,name=name,proto3" json:"name"`
    base                     string             `protobuf:"bytes,3,opt,name=base,proto3" json:"base"`
    quote                    string             `protobuf:"bytes,4,opt,name=quote,proto3" json:"quote"`
    symbol                   string             `protobuf:"bytes,21,opt,name=symbol,proto3" json:"symbol"`
    priceprecision           int32              `protobuf:"varint,5,opt,name=priceprecision,proto3" json:"priceprecision"`
    quantityprecision        int32              `protobuf:"varint,6,opt,name=quantityprecision,proto3" json:"quantityprecision"`
    priceticksize            string             `protobuf:"bytes,7,opt,name=priceticksize,proto3" json:"priceticksize"`
    quantityticksize         string             `protobuf:"bytes,8,opt,name=quantityticksize,proto3" json:"quantityticksize"`
    markettakebound          string             `protobuf:"bytes,9,opt,name=markettakebound,proto3" json:"markettakebound"`
    ordertypes               []ordertype        `protobuf:"varint,10,rep,packed,name=ordertypes,proto3,enum=markets.ordertype" json:"ordertypes"`
    marketstatus             marketstatus       `protobuf:"varint,11,opt,name=marketstatus,proto3,enum=markets.marketstatus" json:"marketstatus"`
    markettype               markettype         `protobuf:"varint,12,opt,name=markettype,proto3,enum=markets.markettype" json:"markettype"`
    timeinforce              []timeinforce      `protobuf:"varint,13,rep,packed,name=timeinforce,proto3,enum=markets.timeinforce" json:"timeinforce"`
    defaultvolumeprofile     *volumeprofile     `protobuf:"bytes,14,opt,name=defaultvolumeprofile,proto3" json:"defaultvolumeprofile"`
    defaultprotectionprofile *protectionprofile `protobuf:"bytes,15,opt,name=defaultprotectionprofile,proto3" json:"defaultprotectionprofile"`
    defaultleverageprofile   *leverageprofile   `protobuf:"bytes,16,opt,name=defaultleverageprofile,proto3" json:"defaultleverageprofile"`
    isopen                   bool               `protobuf:"varint,17,opt,name=isopen,proto3" json:"isopen"`
    nextopecloseinterval     int32              `protobuf:"varint,18,opt,name=nextopecloseinterval,proto3" json:"nextopecloseinterval"`
    interestrateshort        string             `protobuf:"bytes,19,opt,name=interestrateshort,proto3" json:"interestrateshort"`
    interestratelong         string             `protobuf:"bytes,20,opt,name=interestratelong,proto3" json:"interestratelong"`
}

ordertypes 是一个枚举片段，我想在发送到前端之前将其转换为字符串。我的问题是，有没有一种方法可以将 ordertypes 的类型更改为字符串切片，而无需手动创建全新的结构。

这是我当前的解决方案，它非常冗长，我觉得必须有更好的方法来做到这一点（并且它更加动态，因此如果将新参数添加到原型中，我不必更新代码）。理想情况下，它应该是通用的，因为我有其他类似的消息（有我想转换为字符串的枚举）

type MaketInfosShadowd struct {
        markets.MarketInfo
        OrderTypes   []string
        TimeInForce  []string
        MarketStatus string
        MarketType   string
    }

    type AllMarketsResponse struct {
        LeverageProfiles   []*markets.LeverageProfile
        ProtectionProfiles []*markets.ProtectionProfile
        VolumeProfiles     []*markets.VolumeProfile
        MarketInfos        []*MaketInfosShadowd
    }

    func getAllMarketsHandler(c *gin.Context) {
        now := time.Now().UnixNano()
        code := http.StatusOK

        allMarkets, err := GRPCMarketsService.GetAllMarkets(context.Background())

        response := &AllMarketsResponse{}
        response.LeverageProfiles = allMarkets.LeverageProfiles
        response.ProtectionProfiles = allMarkets.ProtectionProfiles
        response.VolumeProfiles = allMarkets.VolumeProfiles

        for _, val := range allMarkets.MarketInfos {
            infos := MaketInfosShadowd{}
            infos.MarketStatus = val.MarketStatus.String()
            infos.MarketType = val.MarketType.String()
            infos.Name = val.Name
            infos.Base = vale.Base
            infos.Quote = vale.Quote
            infos.Symbol = vale.Symbol
            infos.PricePrecision = vale.PricePrecision
            infos.QuantityPrecision = vale.QuantityPrecision
            // I have left the rest out for brevity

            for _, val := range val.OrderTypes {
                infos.OrderTypes = append(infos.OrderTypes, val.String())
            }

            for _, val := range val.TimeInForce {
                infos.TimeInForce = append(infos.TimeInForce, val.String())
            }
            response.MarketInfos = append(response.MarketInfos, &infos)
        }

        if err != nil {
            err := err.(*errorHTTP)
            sendResponse(c, "", now, err.code, err.message)
            return
        }

        sendResponse(c, "", now, code, &response)
    }

正确答案

由于有 JSON 注释，您可以使用 protoJSON 包快速将数据编组为 JSON。然后，您可以使用 json.Unmarshal 将 JSON 解组为 Go 结构。但是，您的代码似乎是合理的。

今天关于《将数据从结构 X 复制到结构 Y，但将一个字段转换为不同类型》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！