Question

我有以下结构......

type Menu struct {
    Id          string     `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
    Name        string     `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"`
    Description string     `protobuf:"bytes,3,opt,name=description" json:"description,omitempty"`
    Mixers      []*Mixer   `protobuf:"bytes,4,rep,name=mixers" json:"mixers,omitempty"`
    Sections    []*Section `protobuf:"bytes,5,rep,name=sections" json:"sections,omitempty"`
}

而且......

type Menu struct {
    ID          bson.ObjectId `json:"id" bson:"_id"`
    Name        string        `json:"name" bson:"name"`
    Description string        `json:"description" bson:"description"`
    Mixers      []Mixer       `json:"mixers" bson:"mixers"`
    Sections    []Section     `json:"sections" bson:"sections"`
}

我基本上需要在两种结构类型之间进行转换，我试图使用mergo，但是这只能合并可以相互转换的结构。到目前为止，我唯一的解决方案是迭代每个结构，通过重新分配ID并在string和bson.ObjectId之间转换它的类型来转换ID。然后迭代每个地图字段并执行相同操作。这感觉就像一个低效的解决方案。

所以我试图在两个ID之间进行转换时使用反射更通用。但我无法弄清楚如何有效地合并所有其他自动匹配的字段，所以我可以担心在ID类型之间进行转换。

这是我到目前为止的代码......

package main

import (
    "fmt"
    "reflect"

    "gopkg.in/mgo.v2/bson"
)

type Sub struct {
    Id bson.ObjectId
}

type PbSub struct {
    Id string
}

type PbMenu struct {
    Id   string
    Subs []PbSub
}

type Menu struct {
    Id   bson.ObjectId
    Subs []Sub
}

func main() {
    pbMenus := []*PbMenu{
        &PbMenu{"1", []PbSub{PbSub{"1"}}},
        &PbMenu{"2", []PbSub{PbSub{"1"}}},
        &PbMenu{"3", []PbSub{PbSub{"1"}}},
    }

    newMenus := Serialise(pbMenus)
    fmt.Println(newMenus)
}

type union struct {
    PbMenu
    Menu
}

func Serialise(menus []*PbMenu) []Menu {
    newMenus := []Menu{}
    for _, v := range menus {
        m := reflect.TypeOf(*v)
        fmt.Println(m)
        length := m.NumField()
        for i := 0; i < length; i++ {
            field := reflect.TypeOf(v).Field(i)
            fmt.Println(field.Type.Kind())
            if field.Type.Kind() == reflect.Map {
                fmt.Println("is map")
            }
            if field.Name == "Id" && field.Type.String() == "string" {

                // Convert ID type
                id := bson.ObjectId(v.Id)
                var dst Menu
                dst.Id = id

                // Need to merge other matching struct fields

                newMenus = append(newMenus, dst)
            }
        }
    }
    return newMenus
}

我不能只是手动重新分配字段，因为我希望在结构字段上检测地图并递归地对它们执行此功能，但是嵌入式结构上的字段不一样。

希望这是有道理的！

Answer 1

我认为编写自己的转换器可能更好，因为你总会遇到一些现有的libs \ tools所没有的案例。

我最初的实现方式如下：basic impl of structs merger

合并两个不同类型的相似结构

1 个答案: